        -:    0:Source:/usr/include/c++/14.1.1/tuple
        -:    0:Graph:/home/kirillg/Coding/MIET/Diploma/cmake-build-debug-coverage/CMakeFiles/Diploma.dir/TestDiploma.cpp.gcno
        -:    0:Data:/home/kirillg/Coding/MIET/Diploma/cmake-build-debug-coverage/CMakeFiles/Diploma.dir/TestDiploma.cpp.gcda
        -:    0:Runs:1
        -:    1:// <tuple> -*- C++ -*-
        -:    2:
        -:    3:// Copyright (C) 2007-2024 Free Software Foundation, Inc.
        -:    4://
        -:    5:// This file is part of the GNU ISO C++ Library.  This library is free
        -:    6:// software; you can redistribute it and/or modify it under the
        -:    7:// terms of the GNU General Public License as published by the
        -:    8:// Free Software Foundation; either version 3, or (at your option)
        -:    9:// any later version.
        -:   10:
        -:   11:// This library is distributed in the hope that it will be useful,
        -:   12:// but WITHOUT ANY WARRANTY; without even the implied warranty of
        -:   13:// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        -:   14:// GNU General Public License for more details.
        -:   15:
        -:   16:// Under Section 7 of GPL version 3, you are granted additional
        -:   17:// permissions described in the GCC Runtime Library Exception, version
        -:   18:// 3.1, as published by the Free Software Foundation.
        -:   19:
        -:   20:// You should have received a copy of the GNU General Public License and
        -:   21:// a copy of the GCC Runtime Library Exception along with this program;
        -:   22:// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
        -:   23:// <http://www.gnu.org/licenses/>.
        -:   24:
        -:   25:/** @file include/tuple
        -:   26: *  This is a Standard C++ Library header.
        -:   27: */
        -:   28:
        -:   29:#ifndef _GLIBCXX_TUPLE
        -:   30:#define _GLIBCXX_TUPLE 1
        -:   31:
        -:   32:#pragma GCC system_header
        -:   33:
        -:   34:#if __cplusplus < 201103L
        -:   35:# include <bits/c++0x_warning.h>
        -:   36:#else
        -:   37:
        -:   38:#include <bits/stl_pair.h>		// for std::pair
        -:   39:#include <bits/uses_allocator.h>	// for std::allocator_arg_t
        -:   40:#include <bits/utility.h>		// for std::tuple_size etc.
        -:   41:#include <bits/invoke.h>		// for std::__invoke
        -:   42:#if __cplusplus > 201703L
        -:   43:# include <compare>
        -:   44:# include <bits/ranges_util.h>		// for std::ranges::subrange
        -:   45:#endif
        -:   46:
        -:   47:#define __glibcxx_want_constexpr_tuple
        -:   48:#define __glibcxx_want_tuple_element_t
        -:   49:#define __glibcxx_want_tuples_by_type
        -:   50:#define __glibcxx_want_apply
        -:   51:#define __glibcxx_want_make_from_tuple
        -:   52:#define __glibcxx_want_ranges_zip
        -:   53:#define __glibcxx_want_tuple_like
        -:   54:#include <bits/version.h>
        -:   55:
        -:   56:namespace std _GLIBCXX_VISIBILITY(default)
        -:   57:{
        -:   58:_GLIBCXX_BEGIN_NAMESPACE_VERSION
        -:   59:
        -:   60:  /**
        -:   61:   *  @addtogroup utilities
        -:   62:   *  @{
        -:   63:   */
        -:   64:
        -:   65:  template<typename... _Elements>
        -:   66:    class tuple;
        -:   67:
        -:   68:  template<typename _Tp>
        -:   69:    struct __is_empty_non_tuple : is_empty<_Tp> { };
        -:   70:
        -:   71:  // Using EBO for elements that are tuples causes ambiguous base errors.
        -:   72:  template<typename _El0, typename... _El>
        -:   73:    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };
        -:   74:
        -:   75:  // Use the Empty Base-class Optimization for empty, non-final types.
        -:   76:  template<typename _Tp>
        -:   77:    using __empty_not_final
        -:   78:    = __conditional_t<__is_final(_Tp), false_type,
        -:   79:		      __is_empty_non_tuple<_Tp>>;
        -:   80:
        -:   81:  template<size_t _Idx, typename _Head,
        -:   82:	   bool = __empty_not_final<_Head>::value>
        -:   83:    struct _Head_base;
        -:   84:
        -:   85:#if __has_cpp_attribute(__no_unique_address__)
        -:   86:  template<size_t _Idx, typename _Head>
        -:   87:    struct _Head_base<_Idx, _Head, true>
        -:   88:    {
    #####:   89:      constexpr _Head_base()
        -:   90:      : _M_head_impl() { }
        -:   91:
        -:   92:      constexpr _Head_base(const _Head& __h)
        -:   93:      : _M_head_impl(__h) { }
        -:   94:
        -:   95:      constexpr _Head_base(const _Head_base&) = default;
        -:   96:      constexpr _Head_base(_Head_base&&) = default;
        -:   97:
        -:   98:      template<typename _UHead>
        -:   99:	constexpr _Head_base(_UHead&& __h)
        -:  100:	: _M_head_impl(std::forward<_UHead>(__h)) { }
        -:  101:
        -:  102:      _GLIBCXX20_CONSTEXPR
        -:  103:      _Head_base(allocator_arg_t, __uses_alloc0)
        -:  104:      : _M_head_impl() { }
        -:  105:
        -:  106:      template<typename _Alloc>
        -:  107:	_GLIBCXX20_CONSTEXPR
        -:  108:	_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
        -:  109:	: _M_head_impl(allocator_arg, *__a._M_a) { }
        -:  110:
        -:  111:      template<typename _Alloc>
        -:  112:	_GLIBCXX20_CONSTEXPR
        -:  113:	_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
        -:  114:	: _M_head_impl(*__a._M_a) { }
        -:  115:
        -:  116:      template<typename _UHead>
        -:  117:	_GLIBCXX20_CONSTEXPR
        -:  118:	_Head_base(__uses_alloc0, _UHead&& __uhead)
        -:  119:	: _M_head_impl(std::forward<_UHead>(__uhead)) { }
        -:  120:
        -:  121:      template<typename _Alloc, typename _UHead>
        -:  122:	_GLIBCXX20_CONSTEXPR
        -:  123:	_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
        -:  124:	: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
        -:  125:	{ }
        -:  126:
        -:  127:      template<typename _Alloc, typename _UHead>
        -:  128:	_GLIBCXX20_CONSTEXPR
        -:  129:	_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
        -:  130:	: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
        -:  131:
        -:  132:      static constexpr _Head&
        -:  133:      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
        -:  134:
        -:  135:      static constexpr const _Head&
        -:  136:      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
        -:  137:
        -:  138:      [[__no_unique_address__]] _Head _M_head_impl;
        -:  139:    };
        -:  140:#else
        -:  141:  template<size_t _Idx, typename _Head>
        -:  142:    struct _Head_base<_Idx, _Head, true>
        -:  143:    : public _Head
        -:  144:    {
        -:  145:      constexpr _Head_base()
        -:  146:      : _Head() { }
        -:  147:
        -:  148:      constexpr _Head_base(const _Head& __h)
        -:  149:      : _Head(__h) { }
        -:  150:
        -:  151:      constexpr _Head_base(const _Head_base&) = default;
        -:  152:      constexpr _Head_base(_Head_base&&) = default;
        -:  153:
        -:  154:      template<typename _UHead>
        -:  155:        constexpr _Head_base(_UHead&& __h)
        -:  156:	: _Head(std::forward<_UHead>(__h)) { }
        -:  157:
        -:  158:      _GLIBCXX20_CONSTEXPR
        -:  159:      _Head_base(allocator_arg_t, __uses_alloc0)
        -:  160:      : _Head() { }
        -:  161:
        -:  162:      template<typename _Alloc>
        -:  163:	_GLIBCXX20_CONSTEXPR
        -:  164:	_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
        -:  165:	: _Head(allocator_arg, *__a._M_a) { }
        -:  166:
        -:  167:      template<typename _Alloc>
        -:  168:	_GLIBCXX20_CONSTEXPR
        -:  169:	_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
        -:  170:	: _Head(*__a._M_a) { }
        -:  171:
        -:  172:      template<typename _UHead>
        -:  173:	_GLIBCXX20_CONSTEXPR
        -:  174:	_Head_base(__uses_alloc0, _UHead&& __uhead)
        -:  175:	: _Head(std::forward<_UHead>(__uhead)) { }
        -:  176:
        -:  177:      template<typename _Alloc, typename _UHead>
        -:  178:	_GLIBCXX20_CONSTEXPR
        -:  179:	_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
        -:  180:	: _Head(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) { }
        -:  181:
        -:  182:      template<typename _Alloc, typename _UHead>
        -:  183:	_GLIBCXX20_CONSTEXPR
        -:  184:	_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
        -:  185:	: _Head(std::forward<_UHead>(__uhead), *__a._M_a) { }
        -:  186:
        -:  187:      static constexpr _Head&
        -:  188:      _M_head(_Head_base& __b) noexcept { return __b; }
        -:  189:
        -:  190:      static constexpr const _Head&
        -:  191:      _M_head(const _Head_base& __b) noexcept { return __b; }
        -:  192:    };
        -:  193:#endif
        -:  194:
        -:  195:  template<size_t _Idx, typename _Head>
        -:  196:    struct _Head_base<_Idx, _Head, false>
        -:  197:    {
    #####:  198:      constexpr _Head_base()
        -:  199:      : _M_head_impl() { }
        -:  200:
        -:  201:      constexpr _Head_base(const _Head& __h)
        -:  202:      : _M_head_impl(__h) { }
        -:  203:
        -:  204:      constexpr _Head_base(const _Head_base&) = default;
        -:  205:      constexpr _Head_base(_Head_base&&) = default;
        -:  206:
        -:  207:      template<typename _UHead>
        -:  208:        constexpr _Head_base(_UHead&& __h)
        -:  209:	: _M_head_impl(std::forward<_UHead>(__h)) { }
        -:  210:
        -:  211:      _GLIBCXX20_CONSTEXPR
        -:  212:      _Head_base(allocator_arg_t, __uses_alloc0)
        -:  213:      : _M_head_impl() { }
        -:  214:
        -:  215:      template<typename _Alloc>
        -:  216:	_GLIBCXX20_CONSTEXPR
        -:  217:	_Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
        -:  218:	: _M_head_impl(allocator_arg, *__a._M_a) { }
        -:  219:
        -:  220:      template<typename _Alloc>
        -:  221:	_GLIBCXX20_CONSTEXPR
        -:  222:	_Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
        -:  223:	: _M_head_impl(*__a._M_a) { }
        -:  224:
        -:  225:      template<typename _UHead>
        -:  226:	_GLIBCXX20_CONSTEXPR
        -:  227:	_Head_base(__uses_alloc0, _UHead&& __uhead)
        -:  228:	: _M_head_impl(std::forward<_UHead>(__uhead)) { }
        -:  229:
        -:  230:      template<typename _Alloc, typename _UHead>
        -:  231:	_GLIBCXX20_CONSTEXPR
        -:  232:	_Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
        -:  233:	: _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
        -:  234:	{ }
        -:  235:
        -:  236:      template<typename _Alloc, typename _UHead>
        -:  237:	_GLIBCXX20_CONSTEXPR
        -:  238:	_Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
        -:  239:	: _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }
        -:  240:
        -:  241:      static constexpr _Head&
        -:  242:      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }
        -:  243:
        -:  244:      static constexpr const _Head&
        -:  245:      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }
        -:  246:
        -:  247:      _Head _M_head_impl;
        -:  248:    };
        -:  249:
        -:  250:#if __cpp_lib_tuple_like // >= C++23
        -:  251:  struct __tuple_like_tag_t { explicit __tuple_like_tag_t() = default; };
        -:  252:
        -:  253:  // These forward declarations are used by the operator<=> overload for
        -:  254:  // tuple-like types.
        -:  255:  template<typename _Cat, typename _Tp, typename _Up>
        -:  256:    constexpr _Cat
        -:  257:    __tuple_cmp(const _Tp&, const _Up&, index_sequence<>);
        -:  258:
        -:  259:  template<typename _Cat, typename _Tp, typename _Up,
        -:  260:	   size_t _Idx0, size_t... _Idxs>
        -:  261:    constexpr _Cat
        -:  262:    __tuple_cmp(const _Tp& __t, const _Up& __u,
        -:  263:		index_sequence<_Idx0, _Idxs...>);
        -:  264:#endif // C++23
        -:  265:
        -:  266:  /**
        -:  267:   * Contains the actual implementation of the @c tuple template, stored
        -:  268:   * as a recursive inheritance hierarchy from the first element (most
        -:  269:   * derived class) to the last (least derived class). The @c Idx
        -:  270:   * parameter gives the 0-based index of the element stored at this
        -:  271:   * point in the hierarchy; we use it to implement a constant-time
        -:  272:   * get() operation.
        -:  273:   */
        -:  274:  template<size_t _Idx, typename... _Elements>
        -:  275:    struct _Tuple_impl;
        -:  276:
        -:  277:  /**
        -:  278:   * Recursive tuple implementation. Here we store the @c Head element
        -:  279:   * and derive from a @c Tuple_impl containing the remaining elements
        -:  280:   * (which contains the @c Tail).
        -:  281:   */
        -:  282:  template<size_t _Idx, typename _Head, typename... _Tail>
        -:  283:    struct _Tuple_impl<_Idx, _Head, _Tail...>
        -:  284:    : public _Tuple_impl<_Idx + 1, _Tail...>,
        -:  285:      private _Head_base<_Idx, _Head>
        -:  286:    {
        -:  287:      template<size_t, typename...> friend struct _Tuple_impl;
        -:  288:
        -:  289:      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
        -:  290:      typedef _Head_base<_Idx, _Head> _Base;
        -:  291:
        -:  292:      static constexpr _Head&
      21*:  293:      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
        -:  294:
        -:  295:      static constexpr const _Head&
        -:  296:      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
        -:  297:
        -:  298:      static constexpr _Inherited&
        -:  299:      _M_tail(_Tuple_impl& __t) noexcept { return __t; }
        -:  300:
        -:  301:      static constexpr const _Inherited&
        -:  302:      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }
        -:  303:
    #####:  304:      constexpr _Tuple_impl()
    #####:  305:      : _Inherited(), _Base() { }
        -:  306:
        -:  307:      explicit constexpr
        -:  308:      _Tuple_impl(const _Head& __head, const _Tail&... __tail)
        -:  309:      : _Inherited(__tail...), _Base(__head)
        -:  310:      { }
        -:  311:
        -:  312:      template<typename _UHead, typename... _UTail,
        -:  313:	       typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
        -:  314:	explicit constexpr
        -:  315:	_Tuple_impl(_UHead&& __head, _UTail&&... __tail)
        -:  316:	: _Inherited(std::forward<_UTail>(__tail)...),
        -:  317:	  _Base(std::forward<_UHead>(__head))
        -:  318:	{ }
        -:  319:
        -:  320:      constexpr _Tuple_impl(const _Tuple_impl&) = default;
        -:  321:
        -:  322:      // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -:  323:      // 2729. Missing SFINAE on std::pair::operator=
        -:  324:      _Tuple_impl& operator=(const _Tuple_impl&) = delete;
        -:  325:
        -:  326:      _Tuple_impl(_Tuple_impl&&) = default;
        -:  327:
        -:  328:      template<typename... _UElements>
        -:  329:	constexpr
        -:  330:	_Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
        -:  331:	: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
        -:  332:	  _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
        -:  333:	{ }
        -:  334:
        -:  335:      template<typename _UHead, typename... _UTails>
        -:  336:	constexpr
        -:  337:	_Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
        -:  338:	: _Inherited(std::move
        -:  339:		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
        -:  340:	  _Base(std::forward<_UHead>
        -:  341:		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
        -:  342:	{ }
        -:  343:
        -:  344:#if __cpp_lib_ranges_zip // >= C++23
        -:  345:      template<typename... _UElements>
        -:  346:	constexpr
        -:  347:	_Tuple_impl(_Tuple_impl<_Idx, _UElements...>& __in)
        -:  348:	: _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
        -:  349:	  _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
        -:  350:	{ }
        -:  351:
        -:  352:      template<typename _UHead, typename... _UTails>
        -:  353:	constexpr
        -:  354:	_Tuple_impl(const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
        -:  355:	: _Inherited(std::move
        -:  356:		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
        -:  357:	  _Base(std::forward<const _UHead>
        -:  358:		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
        -:  359:	{ }
        -:  360:#endif // C++23
        -:  361:
        -:  362:#if __cpp_lib_tuple_like // >= C++23
        -:  363:      template<typename _UTuple, size_t... _Is>
        -:  364:	constexpr
        -:  365:	_Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<_Is...>)
        -:  366:	: _Tuple_impl(std::get<_Is>(std::forward<_UTuple>(__u))...)
        -:  367:	{ }
        -:  368:#endif // C++23
        -:  369:
        -:  370:      template<typename _Alloc>
        -:  371:	_GLIBCXX20_CONSTEXPR
        -:  372:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
        -:  373:	: _Inherited(__tag, __a),
        -:  374:	  _Base(__tag, __use_alloc<_Head>(__a))
        -:  375:	{ }
        -:  376:
        -:  377:      template<typename _Alloc>
        -:  378:	_GLIBCXX20_CONSTEXPR
        -:  379:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  380:		    const _Head& __head, const _Tail&... __tail)
        -:  381:	: _Inherited(__tag, __a, __tail...),
        -:  382:	  _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head)
        -:  383:	{ }
        -:  384:
        -:  385:      template<typename _Alloc, typename _UHead, typename... _UTail,
        -:  386:	       typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
        -:  387:	_GLIBCXX20_CONSTEXPR
        -:  388:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  389:		    _UHead&& __head, _UTail&&... __tail)
        -:  390:	: _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
        -:  391:	  _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
        -:  392:		std::forward<_UHead>(__head))
        -:  393:	{ }
        -:  394:
        -:  395:      template<typename _Alloc>
        -:  396:	_GLIBCXX20_CONSTEXPR
        -:  397:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  398:		    const _Tuple_impl& __in)
        -:  399:	: _Inherited(__tag, __a, _M_tail(__in)),
        -:  400:	  _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in))
        -:  401:	{ }
        -:  402:
        -:  403:      template<typename _Alloc>
        -:  404:	_GLIBCXX20_CONSTEXPR
        -:  405:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  406:		    _Tuple_impl&& __in)
        -:  407:	: _Inherited(__tag, __a, std::move(_M_tail(__in))),
        -:  408:	  _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
        -:  409:		std::forward<_Head>(_M_head(__in)))
        -:  410:	{ }
        -:  411:
        -:  412:      template<typename _Alloc, typename _UHead, typename... _UTails>
        -:  413:	_GLIBCXX20_CONSTEXPR
        -:  414:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  415:		    const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
        -:  416:	: _Inherited(__tag, __a,
        -:  417:		     _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
        -:  418:	  _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
        -:  419:		_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
        -:  420:	{ }
        -:  421:
        -:  422:      template<typename _Alloc, typename _UHead, typename... _UTails>
        -:  423:	_GLIBCXX20_CONSTEXPR
        -:  424:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  425:		    _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
        -:  426:	: _Inherited(__tag, __a, std::move
        -:  427:		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
        -:  428:	  _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
        -:  429:		std::forward<_UHead>
        -:  430:		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
        -:  431:	{ }
        -:  432:
        -:  433:#if __cpp_lib_ranges_zip // >= C++23
        -:  434:      template<typename _Alloc, typename _UHead, typename... _UTails>
        -:  435:	constexpr
        -:  436:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  437:		    _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
        -:  438:	: _Inherited(__tag, __a,
        -:  439:		     _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
        -:  440:	  _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
        -:  441:		_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
        -:  442:	{ }
        -:  443:
        -:  444:      template<typename _Alloc, typename _UHead, typename... _UTails>
        -:  445:	constexpr
        -:  446:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
        -:  447:		    const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
        -:  448:	: _Inherited(__tag, __a, std::move
        -:  449:		     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
        -:  450:	  _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
        -:  451:		std::forward<const _UHead>
        -:  452:		(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
        -:  453:	{ }
        -:  454:#endif // C++23
        -:  455:
        -:  456:#if __cpp_lib_tuple_like // >= C++23
        -:  457:      template<typename _Alloc, typename _UTuple, size_t... _Is>
        -:  458:	constexpr
        -:  459:	_Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a,
        -:  460:		    _UTuple&& __u, index_sequence<_Is...>)
        -:  461:	: _Tuple_impl(__tag, __a, std::get<_Is>(std::forward<_UTuple>(__u))...)
        -:  462:	{ }
        -:  463:#endif // C++23
        -:  464:
        -:  465:      template<typename... _UElements>
        -:  466:	_GLIBCXX20_CONSTEXPR
        -:  467:	void
        -:  468:	_M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
        -:  469:	{
        -:  470:	  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
        -:  471:	  _M_tail(*this)._M_assign(
        -:  472:	      _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
        -:  473:	}
        -:  474:
        -:  475:      template<typename _UHead, typename... _UTails>
        -:  476:	_GLIBCXX20_CONSTEXPR
        -:  477:	void
        -:  478:	_M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
        -:  479:	{
        -:  480:	  _M_head(*this) = std::forward<_UHead>
        -:  481:	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
        -:  482:	  _M_tail(*this)._M_assign(
        -:  483:	      std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
        -:  484:	}
        -:  485:
        -:  486:#if __cpp_lib_ranges_zip // >= C++23
        -:  487:      template<typename... _UElements>
        -:  488:	constexpr void
        -:  489:	_M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) const
        -:  490:	{
        -:  491:	  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
        -:  492:	  _M_tail(*this)._M_assign(
        -:  493:	      _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
        -:  494:	}
        -:  495:
        -:  496:      template<typename _UHead, typename... _UTails>
        -:  497:	constexpr void
        -:  498:	_M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) const
        -:  499:	{
        -:  500:	  _M_head(*this) = std::forward<_UHead>
        -:  501:	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
        -:  502:	  _M_tail(*this)._M_assign(
        -:  503:	      std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
        -:  504:	}
        -:  505:#endif // C++23
        -:  506:
        -:  507:#if __cpp_lib_tuple_like // >= C++23
        -:  508:      template<typename _UTuple>
        -:  509:	constexpr void
        -:  510:	_M_assign(__tuple_like_tag_t __tag, _UTuple&& __u)
        -:  511:	{
        -:  512:	  _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u));
        -:  513:	  _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
        -:  514:	}
        -:  515:
        -:  516:      template<typename _UTuple>
        -:  517:	constexpr void
        -:  518:	_M_assign(__tuple_like_tag_t __tag, _UTuple&& __u) const
        -:  519:	{
        -:  520:	  _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u));
        -:  521:	  _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
        -:  522:	}
        -:  523:#endif // C++23
        -:  524:
        -:  525:    protected:
        -:  526:      _GLIBCXX20_CONSTEXPR
        -:  527:      void
        -:  528:      _M_swap(_Tuple_impl& __in)
        -:  529:      {
        -:  530:	using std::swap;
        -:  531:	swap(_M_head(*this), _M_head(__in));
        -:  532:	_Inherited::_M_swap(_M_tail(__in));
        -:  533:      }
        -:  534:
        -:  535:#if __cpp_lib_ranges_zip // >= C++23
        -:  536:      constexpr void
        -:  537:      _M_swap(const _Tuple_impl& __in) const
        -:  538:      {
        -:  539:	using std::swap;
        -:  540:	swap(_M_head(*this), _M_head(__in));
        -:  541:	_Inherited::_M_swap(_M_tail(__in));
        -:  542:      }
        -:  543:#endif // C++23
        -:  544:    };
        -:  545:
        -:  546:  // Basis case of inheritance recursion.
        -:  547:  template<size_t _Idx, typename _Head>
        -:  548:    struct _Tuple_impl<_Idx, _Head>
        -:  549:    : private _Head_base<_Idx, _Head>
        -:  550:    {
        -:  551:      template<size_t, typename...> friend struct _Tuple_impl;
        -:  552:
        -:  553:      typedef _Head_base<_Idx, _Head> _Base;
        -:  554:
        -:  555:      static constexpr _Head&
    #####:  556:      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
        -:  557:
        -:  558:      static constexpr const _Head&
        -:  559:      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
        -:  560:
        -:  561:      constexpr
    #####:  562:      _Tuple_impl()
    #####:  563:      : _Base() { }
        -:  564:
        -:  565:      explicit constexpr
        -:  566:      _Tuple_impl(const _Head& __head)
        -:  567:      : _Base(__head)
        -:  568:      { }
        -:  569:
        -:  570:      template<typename _UHead>
        -:  571:	explicit constexpr
        -:  572:	_Tuple_impl(_UHead&& __head)
        -:  573:	: _Base(std::forward<_UHead>(__head))
        -:  574:	{ }
        -:  575:
        -:  576:      constexpr _Tuple_impl(const _Tuple_impl&) = default;
        -:  577:
        -:  578:      // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -:  579:      // 2729. Missing SFINAE on std::pair::operator=
        -:  580:      _Tuple_impl& operator=(const _Tuple_impl&) = delete;
        -:  581:
        -:  582:#if _GLIBCXX_INLINE_VERSION
        -:  583:      _Tuple_impl(_Tuple_impl&&) = default;
        -:  584:#else
        -:  585:      constexpr
        -:  586:      _Tuple_impl(_Tuple_impl&& __in)
        -:  587:      noexcept(is_nothrow_move_constructible<_Head>::value)
        -:  588:      : _Base(static_cast<_Base&&>(__in))
        -:  589:      { }
        -:  590:#endif
        -:  591:
        -:  592:      template<typename _UHead>
        -:  593:	constexpr
        -:  594:	_Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
        -:  595:	: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
        -:  596:	{ }
        -:  597:
        -:  598:      template<typename _UHead>
        -:  599:	constexpr
        -:  600:	_Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
        -:  601:	: _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
        -:  602:	{ }
        -:  603:
        -:  604:#if __cpp_lib_ranges_zip // >= C++23
        -:  605:      template<typename _UHead>
        -:  606:	constexpr
        -:  607:	_Tuple_impl(_Tuple_impl<_Idx, _UHead>& __in)
        -:  608:	: _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
        -:  609:	{ }
        -:  610:
        -:  611:      template<typename _UHead>
        -:  612:	constexpr
        -:  613:	_Tuple_impl(const _Tuple_impl<_Idx, _UHead>&& __in)
        -:  614:	: _Base(std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
        -:  615:	{ }
        -:  616:#endif // C++23
        -:  617:
        -:  618:#if __cpp_lib_tuple_like // >= C++23
        -:  619:      template<typename _UTuple>
        -:  620:	constexpr
        -:  621:	_Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<0>)
        -:  622:	: _Tuple_impl(std::get<0>(std::forward<_UTuple>(__u)))
        -:  623:	{ }
        -:  624:#endif // C++23
        -:  625:
        -:  626:      template<typename _Alloc>
        -:  627:	_GLIBCXX20_CONSTEXPR
        -:  628:	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
        -:  629:	: _Base(__tag, __use_alloc<_Head>(__a))
        -:  630:	{ }
        -:  631:
        -:  632:      template<typename _Alloc>
        -:  633:	_GLIBCXX20_CONSTEXPR
        -:  634:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  635:		    const _Head& __head)
        -:  636:	: _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head)
        -:  637:	{ }
        -:  638:
        -:  639:      template<typename _Alloc, typename _UHead>
        -:  640:	_GLIBCXX20_CONSTEXPR
        -:  641:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  642:		    _UHead&& __head)
        -:  643:	: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
        -:  644:		std::forward<_UHead>(__head))
        -:  645:	{ }
        -:  646:
        -:  647:      template<typename _Alloc>
        -:  648:	_GLIBCXX20_CONSTEXPR
        -:  649:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  650:		    const _Tuple_impl& __in)
        -:  651:	: _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in))
        -:  652:	{ }
        -:  653:
        -:  654:      template<typename _Alloc>
        -:  655:	_GLIBCXX20_CONSTEXPR
        -:  656:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  657:		    _Tuple_impl&& __in)
        -:  658:	: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
        -:  659:		std::forward<_Head>(_M_head(__in)))
        -:  660:	{ }
        -:  661:
        -:  662:      template<typename _Alloc, typename _UHead>
        -:  663:	_GLIBCXX20_CONSTEXPR
        -:  664:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  665:		    const _Tuple_impl<_Idx, _UHead>& __in)
        -:  666:	: _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
        -:  667:		_Tuple_impl<_Idx, _UHead>::_M_head(__in))
        -:  668:	{ }
        -:  669:
        -:  670:      template<typename _Alloc, typename _UHead>
        -:  671:	_GLIBCXX20_CONSTEXPR
        -:  672:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  673:		    _Tuple_impl<_Idx, _UHead>&& __in)
        -:  674:	: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
        -:  675:		std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
        -:  676:	{ }
        -:  677:
        -:  678:#if __cpp_lib_ranges_zip // >= C++23
        -:  679:      template<typename _Alloc, typename _UHead>
        -:  680:	constexpr
        -:  681:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  682:		    _Tuple_impl<_Idx, _UHead>& __in)
        -:  683:	: _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
        -:  684:		_Tuple_impl<_Idx, _UHead>::_M_head(__in))
        -:  685:	{ }
        -:  686:
        -:  687:      template<typename _Alloc, typename _UHead>
        -:  688:	constexpr
        -:  689:	_Tuple_impl(allocator_arg_t, const _Alloc& __a,
        -:  690:		    const _Tuple_impl<_Idx, _UHead>&& __in)
        -:  691:	: _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
        -:  692:		std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
        -:  693:	{ }
        -:  694:#endif // C++23
        -:  695:
        -:  696:#if __cpp_lib_tuple_like // >= C++23
        -:  697:      template<typename _Alloc, typename _UTuple>
        -:  698:	constexpr
        -:  699:	_Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a,
        -:  700:		    _UTuple&& __u, index_sequence<0>)
        -:  701:	: _Tuple_impl(__tag, __a, std::get<0>(std::forward<_UTuple>(__u)))
        -:  702:	{ }
        -:  703:#endif // C++23
        -:  704:
        -:  705:      template<typename _UHead>
        -:  706:	_GLIBCXX20_CONSTEXPR
        -:  707:	void
        -:  708:	_M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
        -:  709:	{
        -:  710:	  _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
        -:  711:	}
        -:  712:
        -:  713:      template<typename _UHead>
        -:  714:	_GLIBCXX20_CONSTEXPR
        -:  715:	void
        -:  716:	_M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
        -:  717:	{
        -:  718:	  _M_head(*this)
        -:  719:	    = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
        -:  720:	}
        -:  721:
        -:  722:#if __cpp_lib_ranges_zip // >= C++23
        -:  723:      template<typename _UHead>
        -:  724:	constexpr void
        -:  725:	_M_assign(const _Tuple_impl<_Idx, _UHead>& __in) const
        -:  726:	{
        -:  727:	  _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
        -:  728:	}
        -:  729:
        -:  730:      template<typename _UHead>
        -:  731:	constexpr void
        -:  732:	_M_assign(_Tuple_impl<_Idx, _UHead>&& __in) const
        -:  733:	{
        -:  734:	  _M_head(*this)
        -:  735:	    = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
        -:  736:	}
        -:  737:#endif // C++23
        -:  738:
        -:  739:#if __cpp_lib_tuple_like // >= C++23
        -:  740:    template<typename _UTuple>
        -:  741:      constexpr void
        -:  742:      _M_assign(__tuple_like_tag_t, _UTuple&& __u)
        -:  743:      { _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }
        -:  744:
        -:  745:    template<typename _UTuple>
        -:  746:      constexpr void
        -:  747:      _M_assign(__tuple_like_tag_t, _UTuple&& __u) const
        -:  748:      { _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }
        -:  749:#endif // C++23
        -:  750:
        -:  751:    protected:
        -:  752:      _GLIBCXX20_CONSTEXPR
        -:  753:      void
        -:  754:      _M_swap(_Tuple_impl& __in)
        -:  755:      {
        -:  756:	using std::swap;
        -:  757:	swap(_M_head(*this), _M_head(__in));
        -:  758:      }
        -:  759:
        -:  760:#if __cpp_lib_ranges_zip // >= C++23
        -:  761:      constexpr void
        -:  762:      _M_swap(const _Tuple_impl& __in) const
        -:  763:      {
        -:  764:	using std::swap;
        -:  765:	swap(_M_head(*this), _M_head(__in));
        -:  766:      }
        -:  767:#endif // C++23
        -:  768:    };
        -:  769:
        -:  770:  // Concept utility functions, reused in conditionally-explicit
        -:  771:  // constructors.
        -:  772:  template<bool, typename... _Types>
        -:  773:    struct _TupleConstraints
        -:  774:    {
        -:  775:      template<typename... _UTypes>
        -:  776:	using __constructible = __and_<is_constructible<_Types, _UTypes>...>;
        -:  777:
        -:  778:      template<typename... _UTypes>
        -:  779:	using __convertible = __and_<is_convertible<_UTypes, _Types>...>;
        -:  780:
        -:  781:      // Constraint for a non-explicit constructor.
        -:  782:      // True iff each Ti in _Types... can be constructed from Ui in _UTypes...
        -:  783:      // and every Ui is implicitly convertible to Ti.
        -:  784:      template<typename... _UTypes>
        -:  785:	static constexpr bool __is_implicitly_constructible()
        -:  786:	{
        -:  787:	  return __and_<__constructible<_UTypes...>,
        -:  788:			__convertible<_UTypes...>
        -:  789:			>::value;
        -:  790:	}
        -:  791:
        -:  792:      // Constraint for a non-explicit constructor.
        -:  793:      // True iff each Ti in _Types... can be constructed from Ui in _UTypes...
        -:  794:      // but not every Ui is implicitly convertible to Ti.
        -:  795:      template<typename... _UTypes>
        -:  796:	static constexpr bool __is_explicitly_constructible()
        -:  797:	{
        -:  798:	  return __and_<__constructible<_UTypes...>,
        -:  799:			__not_<__convertible<_UTypes...>>
        -:  800:			>::value;
        -:  801:	}
        -:  802:
        -:  803:      static constexpr bool __is_implicitly_default_constructible()
        -:  804:      {
        -:  805:	return __and_<std::__is_implicitly_default_constructible<_Types>...
        -:  806:		      >::value;
        -:  807:      }
        -:  808:
        -:  809:      static constexpr bool __is_explicitly_default_constructible()
        -:  810:      {
        -:  811:	return __and_<is_default_constructible<_Types>...,
        -:  812:		      __not_<__and_<
        -:  813:			std::__is_implicitly_default_constructible<_Types>...>
        -:  814:		      >>::value;
        -:  815:      }
        -:  816:    };
        -:  817:
        -:  818:  // Partial specialization used when a required precondition isn't met,
        -:  819:  // e.g. when sizeof...(_Types) != sizeof...(_UTypes).
        -:  820:  template<typename... _Types>
        -:  821:    struct _TupleConstraints<false, _Types...>
        -:  822:    {
        -:  823:      template<typename... _UTypes>
        -:  824:	static constexpr bool __is_implicitly_constructible()
        -:  825:	{ return false; }
        -:  826:
        -:  827:      template<typename... _UTypes>
        -:  828:	static constexpr bool __is_explicitly_constructible()
        -:  829:	{ return false; }
        -:  830:    };
        -:  831:
        -:  832:  /// Primary class template, tuple
        -:  833:  template<typename... _Elements>
        -:  834:    class tuple : public _Tuple_impl<0, _Elements...>
        -:  835:    {
        -:  836:      using _Inherited = _Tuple_impl<0, _Elements...>;
        -:  837:
        -:  838:#if __cpp_concepts && __cpp_consteval && __cpp_conditional_explicit // >= C++20
        -:  839:      template<typename... _UTypes>
        -:  840:	static consteval bool
        -:  841:	__constructible()
        -:  842:	{
        -:  843:	  if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
        -:  844:	    return __and_v<is_constructible<_Elements, _UTypes>...>;
        -:  845:	  else
        -:  846:	    return false;
        -:  847:	}
        -:  848:
        -:  849:      template<typename... _UTypes>
        -:  850:	static consteval bool
        -:  851:	__nothrow_constructible()
        -:  852:	{
        -:  853:	  if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
        -:  854:	    return __and_v<is_nothrow_constructible<_Elements, _UTypes>...>;
        -:  855:	  else
        -:  856:	    return false;
        -:  857:	}
        -:  858:
        -:  859:      template<typename... _UTypes>
        -:  860:	static consteval bool
        -:  861:	__convertible()
        -:  862:	{
        -:  863:	  if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
        -:  864:	    return __and_v<is_convertible<_UTypes, _Elements>...>;
        -:  865:	  else
        -:  866:	    return false;
        -:  867:	}
        -:  868:
        -:  869:      // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -:  870:      // 3121. tuple constructor constraints for UTypes&&... overloads
        -:  871:      template<typename... _UTypes>
        -:  872:	static consteval bool
        -:  873:	__disambiguating_constraint()
        -:  874:	{
        -:  875:	  if constexpr (sizeof...(_Elements) != sizeof...(_UTypes))
        -:  876:	    return false;
        -:  877:	  else if constexpr (sizeof...(_Elements) == 1)
        -:  878:	    {
        -:  879:	      using _U0 = typename _Nth_type<0, _UTypes...>::type;
        -:  880:	      return !is_same_v<remove_cvref_t<_U0>, tuple>;
        -:  881:	    }
        -:  882:	  else if constexpr (sizeof...(_Elements) < 4)
        -:  883:	    {
        -:  884:	      using _U0 = typename _Nth_type<0, _UTypes...>::type;
        -:  885:	      if constexpr (!is_same_v<remove_cvref_t<_U0>, allocator_arg_t>)
        -:  886:		return true;
        -:  887:	      else
        -:  888:		{
        -:  889:		  using _T0 = typename _Nth_type<0, _Elements...>::type;
        -:  890:		  return is_same_v<remove_cvref_t<_T0>, allocator_arg_t>;
        -:  891:		}
        -:  892:	    }
        -:  893:	  return true;
        -:  894:	}
        -:  895:
        -:  896:      // Return true iff sizeof...(Types) == 1 && tuple_size_v<TUPLE> == 1
        -:  897:      // and the single element in Types can be initialized from TUPLE,
        -:  898:      // or is the same type as tuple_element_t<0, TUPLE>.
        -:  899:      template<typename _Tuple>
        -:  900:	static consteval bool
        -:  901:	__use_other_ctor()
        -:  902:	{
        -:  903:	  if constexpr (sizeof...(_Elements) != 1)
        -:  904:	    return false;
        -:  905:	  else if constexpr (is_same_v<remove_cvref_t<_Tuple>, tuple>)
        -:  906:	    return true; // Should use a copy/move constructor instead.
        -:  907:	  else
        -:  908:	    {
        -:  909:	      using _Tp = typename _Nth_type<0, _Elements...>::type;
        -:  910:	      if constexpr (is_convertible_v<_Tuple, _Tp>)
        -:  911:		return true;
        -:  912:	      else if constexpr (is_constructible_v<_Tp, _Tuple>)
        -:  913:		return true;
        -:  914:	    }
        -:  915:	  return false;
        -:  916:	}
        -:  917:
        -:  918:      template<typename... _Up>
        -:  919:	static consteval bool
        -:  920:	__dangles()
        -:  921:	{
        -:  922:#if __has_builtin(__reference_constructs_from_temporary)
        -:  923:	  return (__reference_constructs_from_temporary(_Elements, _Up&&)
        -:  924:		    || ...);
        -:  925:#else
        -:  926:	  return false;
        -:  927:#endif
        -:  928:	}
        -:  929:
        -:  930:#if __cpp_lib_tuple_like // >= C++23
        -:  931:      // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -:  932:      // 4045. tuple can create dangling references from tuple-like
        -:  933:      template<typename _UTuple>
        -:  934:	static consteval bool
        -:  935:	__dangles_from_tuple_like()
        -:  936:	{
        -:  937:	  return []<size_t... _Is>(index_sequence<_Is...>) {
        -:  938:	    return __dangles<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
        -:  939:	  }(index_sequence_for<_Elements...>{});
        -:  940:	}
        -:  941:
        -:  942:      template<typename _UTuple>
        -:  943:	static consteval bool
        -:  944:	__constructible_from_tuple_like()
        -:  945:	{
        -:  946:	  return []<size_t... _Is>(index_sequence<_Is...>) {
        -:  947:	    return __constructible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
        -:  948:	  }(index_sequence_for<_Elements...>{});
        -:  949:	}
        -:  950:
        -:  951:      template<typename _UTuple>
        -:  952:	static consteval bool
        -:  953:	__convertible_from_tuple_like()
        -:  954:	{
        -:  955:	  return []<size_t... _Is>(index_sequence<_Is...>) {
        -:  956:	    return __convertible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
        -:  957:	  }(index_sequence_for<_Elements...>{});
        -:  958:	}
        -:  959:#endif // C++23
        -:  960:
        -:  961:    public:
        -:  962:      constexpr
        -:  963:      explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
    #####:  964:      tuple()
        -:  965:      noexcept((is_nothrow_default_constructible_v<_Elements> && ...))
        -:  966:      requires (is_default_constructible_v<_Elements> && ...)
    #####:  967:      : _Inherited()
вызов   0 ни разу не исполнялся
        -:  968:      { }
        -:  969:
        -:  970:      constexpr explicit(!__convertible<const _Elements&...>())
        -:  971:      tuple(const _Elements&... __elements)
        -:  972:      noexcept(__nothrow_constructible<const _Elements&...>())
        -:  973:      requires (__constructible<const _Elements&...>())
        -:  974:      : _Inherited(__elements...)
        -:  975:      { }
        -:  976:
        -:  977:      template<typename... _UTypes>
        -:  978:	requires (__disambiguating_constraint<_UTypes...>())
        -:  979:	  && (__constructible<_UTypes...>())
        -:  980:	  && (!__dangles<_UTypes...>())
        -:  981:	constexpr explicit(!__convertible<_UTypes...>())
        -:  982:	tuple(_UTypes&&... __u)
        -:  983:	noexcept(__nothrow_constructible<_UTypes...>())
        -:  984:	: _Inherited(std::forward<_UTypes>(__u)...)
        -:  985:	{ }
        -:  986:
        -:  987:      template<typename... _UTypes>
        -:  988:	requires (__disambiguating_constraint<_UTypes...>())
        -:  989:	  && (__constructible<_UTypes...>())
        -:  990:	  && (__dangles<_UTypes...>())
        -:  991:	tuple(_UTypes&&...) = delete;
        -:  992:
        -:  993:      constexpr tuple(const tuple&) = default;
        -:  994:
        -:  995:      constexpr tuple(tuple&&) = default;
        -:  996:
        -:  997:      template<typename... _UTypes>
        -:  998:	requires (__constructible<const _UTypes&...>())
        -:  999:	  && (!__use_other_ctor<const tuple<_UTypes...>&>())
        -: 1000:	  && (!__dangles<const _UTypes&...>())
        -: 1001:	constexpr explicit(!__convertible<const _UTypes&...>())
        -: 1002:	tuple(const tuple<_UTypes...>& __u)
        -: 1003:	noexcept(__nothrow_constructible<const _UTypes&...>())
        -: 1004:	: _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
        -: 1005:	{ }
        -: 1006:
        -: 1007:      template<typename... _UTypes>
        -: 1008:	requires (__constructible<const _UTypes&...>())
        -: 1009:	  && (!__use_other_ctor<const tuple<_UTypes...>&>())
        -: 1010:	  && (__dangles<const _UTypes&...>())
        -: 1011:	tuple(const tuple<_UTypes...>&) = delete;
        -: 1012:
        -: 1013:      template<typename... _UTypes>
        -: 1014:	requires (__constructible<_UTypes...>())
        -: 1015:	  && (!__use_other_ctor<tuple<_UTypes...>>())
        -: 1016:	  && (!__dangles<_UTypes...>())
        -: 1017:	constexpr explicit(!__convertible<_UTypes...>())
        -: 1018:	tuple(tuple<_UTypes...>&& __u)
        -: 1019:	noexcept(__nothrow_constructible<_UTypes...>())
        -: 1020:	: _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
        -: 1021:	{ }
        -: 1022:
        -: 1023:      template<typename... _UTypes>
        -: 1024:	requires (__constructible<_UTypes...>())
        -: 1025:	  && (!__use_other_ctor<tuple<_UTypes...>>())
        -: 1026:	  && (__dangles<_UTypes...>())
        -: 1027:	tuple(tuple<_UTypes...>&&) = delete;
        -: 1028:
        -: 1029:#if __cpp_lib_ranges_zip // >= C++23
        -: 1030:      template<typename... _UTypes>
        -: 1031:	requires (__constructible<_UTypes&...>())
        -: 1032:	  && (!__use_other_ctor<tuple<_UTypes...>&>())
        -: 1033:	  && (!__dangles<_UTypes&...>())
        -: 1034:	constexpr explicit(!__convertible<_UTypes&...>())
        -: 1035:	tuple(tuple<_UTypes...>& __u)
        -: 1036:	noexcept(__nothrow_constructible<_UTypes&...>())
        -: 1037:	: _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&>(__u))
        -: 1038:	{ }
        -: 1039:
        -: 1040:      template<typename... _UTypes>
        -: 1041:	requires (__constructible<_UTypes&...>())
        -: 1042:	  && (!__use_other_ctor<tuple<_UTypes...>&>())
        -: 1043:	  && (__dangles<_UTypes&...>())
        -: 1044:	tuple(tuple<_UTypes...>&) = delete;
        -: 1045:
        -: 1046:      template<typename... _UTypes>
        -: 1047:	requires (__constructible<const _UTypes...>())
        -: 1048:	  && (!__use_other_ctor<const tuple<_UTypes...>>())
        -: 1049:	  && (!__dangles<const _UTypes...>())
        -: 1050:	constexpr explicit(!__convertible<const _UTypes...>())
        -: 1051:	tuple(const tuple<_UTypes...>&& __u)
        -: 1052:	noexcept(__nothrow_constructible<const _UTypes...>())
        -: 1053:	: _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u))
        -: 1054:	{ }
        -: 1055:
        -: 1056:      template<typename... _UTypes>
        -: 1057:	requires (__constructible<const _UTypes...>())
        -: 1058:	  && (!__use_other_ctor<const tuple<_UTypes...>>())
        -: 1059:	  && (__dangles<const _UTypes...>())
        -: 1060:	tuple(const tuple<_UTypes...>&&) = delete;
        -: 1061:#endif // C++23
        -: 1062:
        -: 1063:      template<typename _U1, typename _U2>
        -: 1064:	requires (sizeof...(_Elements) == 2)
        -: 1065:	  && (__constructible<const _U1&, const _U2&>())
        -: 1066:	  && (!__dangles<const _U1&, const _U2&>())
        -: 1067:	constexpr explicit(!__convertible<const _U1&, const _U2&>())
        -: 1068:	tuple(const pair<_U1, _U2>& __u)
        -: 1069:	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
        -: 1070:	: _Inherited(__u.first, __u.second)
        -: 1071:	{ }
        -: 1072:
        -: 1073:      template<typename _U1, typename _U2>
        -: 1074:	requires (sizeof...(_Elements) == 2)
        -: 1075:	  && (__constructible<const _U1&, const _U2&>())
        -: 1076:	  && (__dangles<const _U1&, const _U2&>())
        -: 1077:	tuple(const pair<_U1, _U2>&) = delete;
        -: 1078:
        -: 1079:      template<typename _U1, typename _U2>
        -: 1080:	requires (sizeof...(_Elements) == 2)
        -: 1081:	  && (__constructible<_U1, _U2>())
        -: 1082:	  && (!__dangles<_U1, _U2>())
        -: 1083:	constexpr explicit(!__convertible<_U1, _U2>())
        -: 1084:	tuple(pair<_U1, _U2>&& __u)
        -: 1085:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 1086:	: _Inherited(std::forward<_U1>(__u.first),
        -: 1087:		     std::forward<_U2>(__u.second))
        -: 1088:	{ }
        -: 1089:
        -: 1090:      template<typename _U1, typename _U2>
        -: 1091:	requires (sizeof...(_Elements) == 2)
        -: 1092:	  && (__constructible<_U1, _U2>())
        -: 1093:	  && (__dangles<_U1, _U2>())
        -: 1094:	tuple(pair<_U1, _U2>&&) = delete;
        -: 1095:
        -: 1096:#if __cpp_lib_ranges_zip // >= C++23
        -: 1097:      template<typename _U1, typename _U2>
        -: 1098:	requires (sizeof...(_Elements) == 2)
        -: 1099:	  && (__constructible<_U1&, _U2&>())
        -: 1100:	  && (!__dangles<_U1&, _U2&>())
        -: 1101:	constexpr explicit(!__convertible<_U1&, _U2&>())
        -: 1102:	tuple(pair<_U1, _U2>& __u)
        -: 1103:	noexcept(__nothrow_constructible<_U1&, _U2&>())
        -: 1104:	: _Inherited(__u.first, __u.second)
        -: 1105:	{ }
        -: 1106:
        -: 1107:      template<typename _U1, typename _U2>
        -: 1108:	requires (sizeof...(_Elements) == 2)
        -: 1109:	  && (__constructible<_U1&, _U2&>())
        -: 1110:	  && (__dangles<_U1&, _U2&>())
        -: 1111:	tuple(pair<_U1, _U2>&) = delete;
        -: 1112:
        -: 1113:      template<typename _U1, typename _U2>
        -: 1114:	requires (sizeof...(_Elements) == 2)
        -: 1115:	  && (__constructible<const _U1, const _U2>())
        -: 1116:	  && (!__dangles<const _U1, const _U2>())
        -: 1117:	constexpr explicit(!__convertible<const _U1, const _U2>())
        -: 1118:	tuple(const pair<_U1, _U2>&& __u)
        -: 1119:	noexcept(__nothrow_constructible<const _U1, const _U2>())
        -: 1120:	: _Inherited(std::forward<const _U1>(__u.first),
        -: 1121:		     std::forward<const _U2>(__u.second))
        -: 1122:	{ }
        -: 1123:
        -: 1124:      template<typename _U1, typename _U2>
        -: 1125:	requires (sizeof...(_Elements) == 2)
        -: 1126:	  && (__constructible<const _U1, const _U2>())
        -: 1127:	  && (__dangles<const _U1, const _U2>())
        -: 1128:	tuple(const pair<_U1, _U2>&&) = delete;
        -: 1129:#endif // C++23
        -: 1130:
        -: 1131:#if __cpp_lib_tuple_like // >= C++23
        -: 1132:      template<__eligible_tuple_like<tuple> _UTuple>
        -: 1133:	requires (__constructible_from_tuple_like<_UTuple>())
        -: 1134:	  && (!__use_other_ctor<_UTuple>())
        -: 1135:	  && (!__dangles_from_tuple_like<_UTuple>())
        -: 1136:	constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
        -: 1137:	tuple(_UTuple&& __u)
        -: 1138:	: _Inherited(__tuple_like_tag_t{},
        -: 1139:		     std::forward<_UTuple>(__u),
        -: 1140:		     index_sequence_for<_Elements...>{})
        -: 1141:	{ }
        -: 1142:
        -: 1143:      template<__eligible_tuple_like<tuple> _UTuple>
        -: 1144:	requires (__constructible_from_tuple_like<_UTuple>())
        -: 1145:	  && (!__use_other_ctor<_UTuple>())
        -: 1146:	  && (__dangles_from_tuple_like<_UTuple>())
        -: 1147:	tuple(_UTuple&&) = delete;
        -: 1148:#endif // C++23
        -: 1149:
        -: 1150:      // Allocator-extended constructors.
        -: 1151:
        -: 1152:      template<typename _Alloc>
        -: 1153:	constexpr
        -: 1154:	explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
        -: 1155:	tuple(allocator_arg_t __tag, const _Alloc& __a)
        -: 1156:	requires (is_default_constructible_v<_Elements> && ...)
        -: 1157:	: _Inherited(__tag, __a)
        -: 1158:	{ }
        -: 1159:
        -: 1160:      template<typename _Alloc>
        -: 1161:	constexpr explicit(!__convertible<const _Elements&...>())
        -: 1162:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1163:	      const _Elements&... __elements)
        -: 1164:	requires (__constructible<const _Elements&...>())
        -: 1165:	: _Inherited(__tag, __a, __elements...)
        -: 1166:	{ }
        -: 1167:
        -: 1168:      template<typename _Alloc, typename... _UTypes>
        -: 1169:	requires (__disambiguating_constraint<_UTypes...>())
        -: 1170:	  && (__constructible<_UTypes...>())
        -: 1171:	  && (!__dangles<_UTypes...>())
        -: 1172:	constexpr explicit(!__convertible<_UTypes...>())
        -: 1173:	tuple(allocator_arg_t __tag, const _Alloc& __a, _UTypes&&... __u)
        -: 1174:	: _Inherited(__tag, __a, std::forward<_UTypes>(__u)...)
        -: 1175:	{ }
        -: 1176:
        -: 1177:      template<typename _Alloc, typename... _UTypes>
        -: 1178:	requires (__disambiguating_constraint<_UTypes...>())
        -: 1179:	  && (__constructible<_UTypes...>())
        -: 1180:	  && (__dangles<_UTypes...>())
        -: 1181:	tuple(allocator_arg_t, const _Alloc&, _UTypes&&...) = delete;
        -: 1182:
        -: 1183:      template<typename _Alloc>
        -: 1184:	constexpr
        -: 1185:	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __u)
        -: 1186:	: _Inherited(__tag, __a, static_cast<const _Inherited&>(__u))
        -: 1187:	{ }
        -: 1188:
        -: 1189:      template<typename _Alloc>
        -: 1190:	requires (__constructible<_Elements...>())
        -: 1191:	constexpr
        -: 1192:	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __u)
        -: 1193:	: _Inherited(__tag, __a, static_cast<_Inherited&&>(__u))
        -: 1194:	{ }
        -: 1195:
        -: 1196:      template<typename _Alloc, typename... _UTypes>
        -: 1197:	requires (__constructible<const _UTypes&...>())
        -: 1198:	  && (!__use_other_ctor<const tuple<_UTypes...>&>())
        -: 1199:	  && (!__dangles<const _UTypes&...>())
        -: 1200:	constexpr explicit(!__convertible<const _UTypes&...>())
        -: 1201:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1202:	      const tuple<_UTypes...>& __u)
        -: 1203:	: _Inherited(__tag, __a,
        -: 1204:		     static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
        -: 1205:	{ }
        -: 1206:
        -: 1207:      template<typename _Alloc, typename... _UTypes>
        -: 1208:	requires (__constructible<const _UTypes&...>())
        -: 1209:	  && (!__use_other_ctor<const tuple<_UTypes...>&>())
        -: 1210:	  && (__dangles<const _UTypes&...>())
        -: 1211:	tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&) = delete;
        -: 1212:
        -: 1213:      template<typename _Alloc, typename... _UTypes>
        -: 1214:	requires (__constructible<_UTypes...>())
        -: 1215:	  && (!__use_other_ctor<tuple<_UTypes...>>())
        -: 1216:	  && (!__dangles<_UTypes...>())
        -: 1217:	constexpr explicit(!__use_other_ctor<tuple<_UTypes...>>())
        -: 1218:	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>&& __u)
        -: 1219:	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
        -: 1220:	{ }
        -: 1221:
        -: 1222:      template<typename _Alloc, typename... _UTypes>
        -: 1223:	requires (__constructible<_UTypes...>())
        -: 1224:	  && (!__use_other_ctor<tuple<_UTypes...>>())
        -: 1225:	  && (__dangles<_UTypes...>())
        -: 1226:	tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&&) = delete;
        -: 1227:
        -: 1228:#if __cpp_lib_ranges_zip // >= C++23
        -: 1229:      template<typename _Alloc, typename... _UTypes>
        -: 1230:	requires (__constructible<_UTypes&...>())
        -: 1231:	  && (!__use_other_ctor<tuple<_UTypes...>&>())
        -: 1232:	  && (!__dangles<_UTypes&...>())
        -: 1233:	constexpr explicit(!__convertible<_UTypes&...>())
        -: 1234:	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>& __u)
        -: 1235:	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&>(__u))
        -: 1236:	{ }
        -: 1237:
        -: 1238:      template<typename _Alloc, typename... _UTypes>
        -: 1239:	requires (__constructible<_UTypes&...>())
        -: 1240:	  && (!__use_other_ctor<tuple<_UTypes...>&>())
        -: 1241:	  && (__dangles<_UTypes&...>())
        -: 1242:	tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&) = delete;
        -: 1243:
        -: 1244:      template<typename _Alloc, typename... _UTypes>
        -: 1245:	requires (__constructible<const _UTypes...>())
        -: 1246:	  && (!__use_other_ctor<const tuple<_UTypes...>>())
        -: 1247:	  && (!__dangles<const _UTypes...>())
        -: 1248:	constexpr explicit(!__convertible<const _UTypes...>())
        -: 1249:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1250:	      const tuple<_UTypes...>&& __u)
        -: 1251:	: _Inherited(__tag, __a,
        -: 1252:		     static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u))
        -: 1253:	{ }
        -: 1254:
        -: 1255:      template<typename _Alloc, typename... _UTypes>
        -: 1256:	requires (__constructible<const _UTypes...>())
        -: 1257:	  && (!__use_other_ctor<const tuple<_UTypes...>>())
        -: 1258:	  && (__dangles<const _UTypes...>())
        -: 1259:	tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&&) = delete;
        -: 1260:#endif // C++23
        -: 1261:
        -: 1262:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1263:	requires (sizeof...(_Elements) == 2)
        -: 1264:	  && (__constructible<const _U1&, const _U2&>())
        -: 1265:	  && (!__dangles<const _U1&, const _U2&>())
        -: 1266:	constexpr explicit(!__convertible<const _U1&, const _U2&>())
        -: 1267:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1268:	      const pair<_U1, _U2>& __u)
        -: 1269:	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
        -: 1270:	: _Inherited(__tag, __a, __u.first, __u.second)
        -: 1271:	{ }
        -: 1272:
        -: 1273:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1274:	requires (sizeof...(_Elements) == 2)
        -: 1275:	  && (__constructible<const _U1&, const _U2&>())
        -: 1276:	  && (__dangles<const _U1&, const _U2&>())
        -: 1277:	tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&) = delete;
        -: 1278:
        -: 1279:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1280:	requires (sizeof...(_Elements) == 2)
        -: 1281:	  && (__constructible<_U1, _U2>())
        -: 1282:	  && (!__dangles<_U1, _U2>())
        -: 1283:	constexpr explicit(!__convertible<_U1, _U2>())
        -: 1284:	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __u)
        -: 1285:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 1286:	: _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second))
        -: 1287:	{ }
        -: 1288:
        -: 1289:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1290:	requires (sizeof...(_Elements) == 2)
        -: 1291:	  && (__constructible<_U1, _U2>())
        -: 1292:	  && (__dangles<_U1, _U2>())
        -: 1293:	tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&&) = delete;
        -: 1294:
        -: 1295:#if __cpp_lib_ranges_zip // >= C++23
        -: 1296:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1297:	requires (sizeof...(_Elements) == 2)
        -: 1298:	  && (__constructible<_U1&, _U2&>())
        -: 1299:	  && (!__dangles<_U1&, _U2&>())
        -: 1300:	constexpr explicit(!__convertible<_U1&, _U2&>())
        -: 1301:	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>& __u)
        -: 1302:	noexcept(__nothrow_constructible<_U1&, _U2&>())
        -: 1303:	: _Inherited(__tag, __a, __u.first, __u.second)
        -: 1304:	{ }
        -: 1305:
        -: 1306:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1307:	requires (sizeof...(_Elements) == 2)
        -: 1308:	  && (__constructible<_U1&, _U2&>())
        -: 1309:	  && (__dangles<_U1&, _U2&>())
        -: 1310:	tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&) = delete;
        -: 1311:
        -: 1312:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1313:	requires (sizeof...(_Elements) == 2)
        -: 1314:	  && (__constructible<const _U1, const _U2>())
        -: 1315:	  && (!__dangles<const _U1, const _U2>())
        -: 1316:	constexpr explicit(!__convertible<const _U1, const _U2>())
        -: 1317:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1318:	const pair<_U1, _U2>&& __u)
        -: 1319:	noexcept(__nothrow_constructible<const _U1, const _U2>())
        -: 1320:	: _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second))
        -: 1321:	{ }
        -: 1322:
        -: 1323:      template<typename _Alloc, typename _U1, typename _U2>
        -: 1324:	requires (sizeof...(_Elements) == 2)
        -: 1325:	  && (__constructible<const _U1, const _U2>())
        -: 1326:	  && (__dangles<const _U1, const _U2>())
        -: 1327:	tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&&) = delete;
        -: 1328:#endif // C++23
        -: 1329:
        -: 1330:#if __cpp_lib_tuple_like // >= C++23
        -: 1331:      template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple>
        -: 1332:	requires (__constructible_from_tuple_like<_UTuple>())
        -: 1333:	  && (!__use_other_ctor<_UTuple>())
        -: 1334:	  && (!__dangles_from_tuple_like<_UTuple>())
        -: 1335:	constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
        -: 1336:	tuple(allocator_arg_t __tag, const _Alloc& __a, _UTuple&& __u)
        -: 1337:	: _Inherited(__tuple_like_tag_t{},
        -: 1338:		     __tag, __a, std::forward<_UTuple>(__u),
        -: 1339:		     index_sequence_for<_Elements...>{})
        -: 1340:	{ }
        -: 1341:
        -: 1342:      template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple>
        -: 1343:	requires (__constructible_from_tuple_like<_UTuple>())
        -: 1344:	  && (!__use_other_ctor<_UTuple>())
        -: 1345:	  && (__dangles_from_tuple_like<_UTuple>())
        -: 1346:	tuple(allocator_arg_t, const _Alloc&, _UTuple&&) = delete;
        -: 1347:#endif // C++23
        -: 1348:
        -: 1349:#else // !(concepts && conditional_explicit)
        -: 1350:
        -: 1351:      template<bool _Cond>
        -: 1352:	using _TCC = _TupleConstraints<_Cond, _Elements...>;
        -: 1353:
        -: 1354:      // Constraint for non-explicit default constructor
        -: 1355:      template<bool _Dummy>
        -: 1356:	using _ImplicitDefaultCtor = __enable_if_t<
        -: 1357:	  _TCC<_Dummy>::__is_implicitly_default_constructible(),
        -: 1358:	  bool>;
        -: 1359:
        -: 1360:      // Constraint for explicit default constructor
        -: 1361:      template<bool _Dummy>
        -: 1362:	using _ExplicitDefaultCtor = __enable_if_t<
        -: 1363:	  _TCC<_Dummy>::__is_explicitly_default_constructible(),
        -: 1364:	  bool>;
        -: 1365:
        -: 1366:      // Constraint for non-explicit constructors
        -: 1367:      template<bool _Cond, typename... _Args>
        -: 1368:	using _ImplicitCtor = __enable_if_t<
        -: 1369:	  _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(),
        -: 1370:	  bool>;
        -: 1371:
        -: 1372:      // Constraint for non-explicit constructors
        -: 1373:      template<bool _Cond, typename... _Args>
        -: 1374:	using _ExplicitCtor = __enable_if_t<
        -: 1375:	  _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(),
        -: 1376:	  bool>;
        -: 1377:
        -: 1378:      // Condition for noexcept-specifier of a constructor.
        -: 1379:      template<typename... _UElements>
        -: 1380:	static constexpr bool __nothrow_constructible()
        -: 1381:	{
        -: 1382:	  return
        -: 1383:	    __and_<is_nothrow_constructible<_Elements, _UElements>...>::value;
        -: 1384:	}
        -: 1385:
        -: 1386:      // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) == 1.
        -: 1387:      template<typename _Up>
        -: 1388:	static constexpr bool __valid_args()
        -: 1389:	{
        -: 1390:	  return sizeof...(_Elements) == 1
        -: 1391:	    && !is_same<tuple, __remove_cvref_t<_Up>>::value;
        -: 1392:	}
        -: 1393:
        -: 1394:      // Constraint for tuple(_UTypes&&...) where sizeof...(_UTypes) > 1.
        -: 1395:      template<typename, typename, typename... _Tail>
        -: 1396:	static constexpr bool __valid_args()
        -: 1397:	{ return (sizeof...(_Tail) + 2) == sizeof...(_Elements); }
        -: 1398:
        -: 1399:      /* Constraint for constructors with a tuple<UTypes...> parameter ensures
        -: 1400:       * that the constructor is only viable when it would not interfere with
        -: 1401:       * tuple(UTypes&&...) or tuple(const tuple&) or tuple(tuple&&).
        -: 1402:       * Such constructors are only viable if:
        -: 1403:       * either sizeof...(Types) != 1,
        -: 1404:       * or (when Types... expands to T and UTypes... expands to U)
        -: 1405:       * is_convertible_v<TUPLE, T>, is_constructible_v<T, TUPLE>,
        -: 1406:       * and is_same_v<T, U> are all false.
        -: 1407:       */
        -: 1408:      template<typename _Tuple, typename = tuple,
        -: 1409:	       typename = __remove_cvref_t<_Tuple>>
        -: 1410:	struct _UseOtherCtor
        -: 1411:	: false_type
        -: 1412:	{ };
        -: 1413:      // If TUPLE is convertible to the single element in *this,
        -: 1414:      // then TUPLE should match tuple(UTypes&&...) instead.
        -: 1415:      template<typename _Tuple, typename _Tp, typename _Up>
        -: 1416:	struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>>
        -: 1417:	: __or_<is_convertible<_Tuple, _Tp>, is_constructible<_Tp, _Tuple>>::type
        -: 1418:	{ };
        -: 1419:      // If TUPLE and *this each have a single element of the same type,
        -: 1420:      // then TUPLE should match a copy/move constructor instead.
        -: 1421:      template<typename _Tuple, typename _Tp>
        -: 1422:	struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>>
        -: 1423:	: true_type
        -: 1424:	{ };
        -: 1425:
        -: 1426:      // Return true iff sizeof...(Types) == 1 && tuple_size_v<TUPLE> == 1
        -: 1427:      // and the single element in Types can be initialized from TUPLE,
        -: 1428:      // or is the same type as tuple_element_t<0, TUPLE>.
        -: 1429:      template<typename _Tuple>
        -: 1430:	static constexpr bool __use_other_ctor()
        -: 1431:	{ return _UseOtherCtor<_Tuple>::value; }
        -: 1432:
        -: 1433:      /// @cond undocumented
        -: 1434:#undef __glibcxx_no_dangling_refs
        -: 1435:#if __has_builtin(__reference_constructs_from_temporary) \
        -: 1436:      && defined _GLIBCXX_DEBUG
        -: 1437:      // Error if construction from U... would create a dangling ref.
        -: 1438:# if __cpp_fold_expressions
        -: 1439:#  define __glibcxx_dangling_refs(U) \
        -: 1440:  (__reference_constructs_from_temporary(_Elements, U) || ...)
        -: 1441:# else
        -: 1442:#  define __glibcxx_dangling_refs(U) \
        -: 1443:  __or_<__bool_constant<__reference_constructs_from_temporary(_Elements, U) \
        -: 1444:       >...>::value
        -: 1445:# endif
        -: 1446:# define __glibcxx_no_dangling_refs(U) \
        -: 1447:  static_assert(!__glibcxx_dangling_refs(U), \
        -: 1448:		"std::tuple constructor creates a dangling reference")
        -: 1449:#else
        -: 1450:# define __glibcxx_no_dangling_refs(U)
        -: 1451:#endif
        -: 1452:      /// @endcond
        -: 1453:
        -: 1454:    public:
        -: 1455:      template<typename _Dummy = void,
        -: 1456:	       _ImplicitDefaultCtor<is_void<_Dummy>::value> = true>
        -: 1457:	constexpr
        -: 1458:	tuple()
        -: 1459:	noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
        -: 1460:	: _Inherited() { }
        -: 1461:
        -: 1462:      template<typename _Dummy = void,
        -: 1463:	       _ExplicitDefaultCtor<is_void<_Dummy>::value> = false>
        -: 1464:	explicit constexpr
        -: 1465:	tuple()
        -: 1466:	noexcept(__and_<is_nothrow_default_constructible<_Elements>...>::value)
        -: 1467:	: _Inherited() { }
        -: 1468:
        -: 1469:      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
        -: 1470:	       _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
        -: 1471:	constexpr
        -: 1472:	tuple(const _Elements&... __elements)
        -: 1473:	noexcept(__nothrow_constructible<const _Elements&...>())
        -: 1474:	: _Inherited(__elements...) { }
        -: 1475:
        -: 1476:      template<bool _NotEmpty = (sizeof...(_Elements) >= 1),
        -: 1477:	       _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
        -: 1478:	explicit constexpr
        -: 1479:	tuple(const _Elements&... __elements)
        -: 1480:	noexcept(__nothrow_constructible<const _Elements&...>())
        -: 1481:	: _Inherited(__elements...) { }
        -: 1482:
        -: 1483:      template<typename... _UElements,
        -: 1484:	       bool _Valid = __valid_args<_UElements...>(),
        -: 1485:	       _ImplicitCtor<_Valid, _UElements...> = true>
        -: 1486:	constexpr
        -: 1487:	tuple(_UElements&&... __elements)
        -: 1488:	noexcept(__nothrow_constructible<_UElements...>())
        -: 1489:	: _Inherited(std::forward<_UElements>(__elements)...)
        -: 1490:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1491:
        -: 1492:      template<typename... _UElements,
        -: 1493:	       bool _Valid = __valid_args<_UElements...>(),
        -: 1494:	       _ExplicitCtor<_Valid, _UElements...> = false>
        -: 1495:	explicit constexpr
        -: 1496:	tuple(_UElements&&... __elements)
        -: 1497:	noexcept(__nothrow_constructible<_UElements...>())
        -: 1498:	: _Inherited(std::forward<_UElements>(__elements)...)
        -: 1499:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1500:
        -: 1501:      constexpr tuple(const tuple&) = default;
        -: 1502:
        -: 1503:      constexpr tuple(tuple&&) = default;
        -: 1504:
        -: 1505:      template<typename... _UElements,
        -: 1506:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1507:			   && !__use_other_ctor<const tuple<_UElements...>&>(),
        -: 1508:	       _ImplicitCtor<_Valid, const _UElements&...> = true>
        -: 1509:	constexpr
        -: 1510:	tuple(const tuple<_UElements...>& __in)
        -: 1511:	noexcept(__nothrow_constructible<const _UElements&...>())
        -: 1512:	: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
        -: 1513:	{ __glibcxx_no_dangling_refs(const _UElements&); }
        -: 1514:
        -: 1515:      template<typename... _UElements,
        -: 1516:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1517:			   && !__use_other_ctor<const tuple<_UElements...>&>(),
        -: 1518:	       _ExplicitCtor<_Valid, const _UElements&...> = false>
        -: 1519:	explicit constexpr
        -: 1520:	tuple(const tuple<_UElements...>& __in)
        -: 1521:	noexcept(__nothrow_constructible<const _UElements&...>())
        -: 1522:	: _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
        -: 1523:	{ __glibcxx_no_dangling_refs(const _UElements&); }
        -: 1524:
        -: 1525:      template<typename... _UElements,
        -: 1526:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1527:			     && !__use_other_ctor<tuple<_UElements...>&&>(),
        -: 1528:	       _ImplicitCtor<_Valid, _UElements...> = true>
        -: 1529:	constexpr
        -: 1530:	tuple(tuple<_UElements...>&& __in)
        -: 1531:	noexcept(__nothrow_constructible<_UElements...>())
        -: 1532:	: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
        -: 1533:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1534:
        -: 1535:      template<typename... _UElements,
        -: 1536:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1537:			     && !__use_other_ctor<tuple<_UElements...>&&>(),
        -: 1538:	       _ExplicitCtor<_Valid, _UElements...> = false>
        -: 1539:	explicit constexpr
        -: 1540:	tuple(tuple<_UElements...>&& __in)
        -: 1541:	noexcept(__nothrow_constructible<_UElements...>())
        -: 1542:	: _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
        -: 1543:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1544:
        -: 1545:      // Allocator-extended constructors.
        -: 1546:
        -: 1547:      template<typename _Alloc,
        -: 1548:	       _ImplicitDefaultCtor<is_object<_Alloc>::value> = true>
        -: 1549:	_GLIBCXX20_CONSTEXPR
        -: 1550:	tuple(allocator_arg_t __tag, const _Alloc& __a)
        -: 1551:	: _Inherited(__tag, __a) { }
        -: 1552:
        -: 1553:      template<typename _Alloc,
        -: 1554:	       _ExplicitDefaultCtor<is_object<_Alloc>::value> = false>
        -: 1555:	_GLIBCXX20_CONSTEXPR
        -: 1556:	explicit
        -: 1557:	tuple(allocator_arg_t __tag, const _Alloc& __a)
        -: 1558:	: _Inherited(__tag, __a) { }
        -: 1559:
        -: 1560:      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
        -: 1561:	       _ImplicitCtor<_NotEmpty, const _Elements&...> = true>
        -: 1562:	_GLIBCXX20_CONSTEXPR
        -: 1563:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1564:	      const _Elements&... __elements)
        -: 1565:	: _Inherited(__tag, __a, __elements...) { }
        -: 1566:
        -: 1567:      template<typename _Alloc, bool _NotEmpty = (sizeof...(_Elements) >= 1),
        -: 1568:	       _ExplicitCtor<_NotEmpty, const _Elements&...> = false>
        -: 1569:	_GLIBCXX20_CONSTEXPR
        -: 1570:	explicit
        -: 1571:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1572:	      const _Elements&... __elements)
        -: 1573:	: _Inherited(__tag, __a, __elements...) { }
        -: 1574:
        -: 1575:      template<typename _Alloc, typename... _UElements,
        -: 1576:	       bool _Valid = __valid_args<_UElements...>(),
        -: 1577:	       _ImplicitCtor<_Valid, _UElements...> = true>
        -: 1578:	_GLIBCXX20_CONSTEXPR
        -: 1579:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1580:	      _UElements&&... __elements)
        -: 1581:	: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
        -: 1582:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1583:
        -: 1584:      template<typename _Alloc, typename... _UElements,
        -: 1585:		 bool _Valid = __valid_args<_UElements...>(),
        -: 1586:	       _ExplicitCtor<_Valid, _UElements...> = false>
        -: 1587:	_GLIBCXX20_CONSTEXPR
        -: 1588:	explicit
        -: 1589:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1590:	      _UElements&&... __elements)
        -: 1591:	: _Inherited(__tag, __a, std::forward<_UElements>(__elements)...)
        -: 1592:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1593:
        -: 1594:      template<typename _Alloc>
        -: 1595:	_GLIBCXX20_CONSTEXPR
        -: 1596:	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
        -: 1597:	: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
        -: 1598:
        -: 1599:      template<typename _Alloc>
        -: 1600:	_GLIBCXX20_CONSTEXPR
        -: 1601:	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
        -: 1602:	: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
        -: 1603:
        -: 1604:      template<typename _Alloc, typename... _UElements,
        -: 1605:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1606:			     && !__use_other_ctor<const tuple<_UElements...>&>(),
        -: 1607:	       _ImplicitCtor<_Valid, const _UElements&...> = true>
        -: 1608:	_GLIBCXX20_CONSTEXPR
        -: 1609:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1610:	      const tuple<_UElements...>& __in)
        -: 1611:	: _Inherited(__tag, __a,
        -: 1612:		     static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
        -: 1613:	{ __glibcxx_no_dangling_refs(const _UElements&); }
        -: 1614:
        -: 1615:      template<typename _Alloc, typename... _UElements,
        -: 1616:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1617:			     && !__use_other_ctor<const tuple<_UElements...>&>(),
        -: 1618:	       _ExplicitCtor<_Valid, const _UElements&...> = false>
        -: 1619:	_GLIBCXX20_CONSTEXPR
        -: 1620:	explicit
        -: 1621:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1622:	      const tuple<_UElements...>& __in)
        -: 1623:	: _Inherited(__tag, __a,
        -: 1624:		     static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
        -: 1625:	{ __glibcxx_no_dangling_refs(const _UElements&); }
        -: 1626:
        -: 1627:      template<typename _Alloc, typename... _UElements,
        -: 1628:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1629:			     && !__use_other_ctor<tuple<_UElements...>&&>(),
        -: 1630:	       _ImplicitCtor<_Valid, _UElements...> = true>
        -: 1631:	_GLIBCXX20_CONSTEXPR
        -: 1632:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1633:	      tuple<_UElements...>&& __in)
        -: 1634:	: _Inherited(__tag, __a,
        -: 1635:		     static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
        -: 1636:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1637:
        -: 1638:      template<typename _Alloc, typename... _UElements,
        -: 1639:	       bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
        -: 1640:			     && !__use_other_ctor<tuple<_UElements...>&&>(),
        -: 1641:	       _ExplicitCtor<_Valid, _UElements...> = false>
        -: 1642:	_GLIBCXX20_CONSTEXPR
        -: 1643:	explicit
        -: 1644:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 1645:	      tuple<_UElements...>&& __in)
        -: 1646:	: _Inherited(__tag, __a,
        -: 1647:		     static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
        -: 1648:	{ __glibcxx_no_dangling_refs(_UElements&&); }
        -: 1649:#endif // concepts && conditional_explicit
        -: 1650:
        -: 1651:      // tuple assignment
        -: 1652:
        -: 1653:#if __cpp_concepts && __cpp_consteval // >= C++20
        -: 1654:    private:
        -: 1655:      template<typename... _UTypes>
        -: 1656:	static consteval bool
        -: 1657:	__assignable()
        -: 1658:	{
        -: 1659:	  if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
        -: 1660:	    return __and_v<is_assignable<_Elements&, _UTypes>...>;
        -: 1661:	  else
        -: 1662:	    return false;
        -: 1663:	}
        -: 1664:
        -: 1665:      template<typename... _UTypes>
        -: 1666:	static consteval bool
        -: 1667:	__nothrow_assignable()
        -: 1668:	{
        -: 1669:	  if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
        -: 1670:	    return __and_v<is_nothrow_assignable<_Elements&, _UTypes>...>;
        -: 1671:	  else
        -: 1672:	    return false;
        -: 1673:	}
        -: 1674:
        -: 1675:#if __cpp_lib_ranges_zip // >= C++23
        -: 1676:      template<typename... _UTypes>
        -: 1677:	static consteval bool
        -: 1678:	__const_assignable()
        -: 1679:	{
        -: 1680:	  if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
        -: 1681:	    return __and_v<is_assignable<const _Elements&, _UTypes>...>;
        -: 1682:	  else
        -: 1683:	    return false;
        -: 1684:	}
        -: 1685:#endif // C++23
        -: 1686:
        -: 1687:#if __cpp_lib_tuple_like // >= C++23
        -: 1688:      template<typename _UTuple>
        -: 1689:	static consteval bool
        -: 1690:	__assignable_from_tuple_like()
        -: 1691:	{
        -: 1692:	  return []<size_t... _Is>(index_sequence<_Is...>) {
        -: 1693:	    return __assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
        -: 1694:	  }(index_sequence_for<_Elements...>{});
        -: 1695:	}
        -: 1696:
        -: 1697:      template<typename _UTuple>
        -: 1698:	static consteval bool
        -: 1699:	__const_assignable_from_tuple_like()
        -: 1700:	{
        -: 1701:	  return []<size_t... _Is>(index_sequence<_Is...>) {
        -: 1702:	    return __const_assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
        -: 1703:	  }(index_sequence_for<_Elements...>{});
        -: 1704:	}
        -: 1705:#endif // C++23
        -: 1706:
        -: 1707:    public:
        -: 1708:
        -: 1709:      tuple& operator=(const tuple& __u) = delete;
        -: 1710:
        -: 1711:      constexpr tuple&
        -: 1712:      operator=(const tuple& __u)
        -: 1713:      noexcept(__nothrow_assignable<const _Elements&...>())
        -: 1714:      requires (__assignable<const _Elements&...>())
        -: 1715:      {
        -: 1716:	this->_M_assign(__u);
        -: 1717:	return *this;
        -: 1718:      }
        -: 1719:
        -: 1720:      constexpr tuple&
        -: 1721:      operator=(tuple&& __u)
        -: 1722:      noexcept(__nothrow_assignable<_Elements...>())
        -: 1723:      requires (__assignable<_Elements...>())
        -: 1724:      {
        -: 1725:	this->_M_assign(std::move(__u));
        -: 1726:	return *this;
        -: 1727:      }
        -: 1728:
        -: 1729:      template<typename... _UTypes>
        -: 1730:	requires (__assignable<const _UTypes&...>())
        -: 1731:	constexpr tuple&
        -: 1732:	operator=(const tuple<_UTypes...>& __u)
        -: 1733:	noexcept(__nothrow_assignable<const _UTypes&...>())
        -: 1734:	{
        -: 1735:	  this->_M_assign(__u);
        -: 1736:	  return *this;
        -: 1737:	}
        -: 1738:
        -: 1739:      template<typename... _UTypes>
        -: 1740:	requires (__assignable<_UTypes...>())
        -: 1741:	constexpr tuple&
        -: 1742:	operator=(tuple<_UTypes...>&& __u)
        -: 1743:	noexcept(__nothrow_assignable<_UTypes...>())
        -: 1744:	{
        -: 1745:	  this->_M_assign(std::move(__u));
        -: 1746:	  return *this;
        -: 1747:	}
        -: 1748:
        -: 1749:#if __cpp_lib_ranges_zip // >= C++23
        -: 1750:      constexpr const tuple&
        -: 1751:      operator=(const tuple& __u) const
        -: 1752:      requires (__const_assignable<const _Elements&...>())
        -: 1753:      {
        -: 1754:	this->_M_assign(__u);
        -: 1755:	return *this;
        -: 1756:      }
        -: 1757:
        -: 1758:      constexpr const tuple&
        -: 1759:      operator=(tuple&& __u) const
        -: 1760:      requires (__const_assignable<_Elements...>())
        -: 1761:      {
        -: 1762:	this->_M_assign(std::move(__u));
        -: 1763:	return *this;
        -: 1764:      }
        -: 1765:
        -: 1766:      template<typename... _UTypes>
        -: 1767:	constexpr const tuple&
        -: 1768:	operator=(const tuple<_UTypes...>& __u) const
        -: 1769:	requires (__const_assignable<const _UTypes&...>())
        -: 1770:	{
        -: 1771:	  this->_M_assign(__u);
        -: 1772:	  return *this;
        -: 1773:	}
        -: 1774:
        -: 1775:      template<typename... _UTypes>
        -: 1776:	constexpr const tuple&
        -: 1777:	operator=(tuple<_UTypes...>&& __u) const
        -: 1778:	requires (__const_assignable<_UTypes...>())
        -: 1779:	{
        -: 1780:	  this->_M_assign(std::move(__u));
        -: 1781:	  return *this;
        -: 1782:	}
        -: 1783:#endif // C++23
        -: 1784:
        -: 1785:      template<typename _U1, typename _U2>
        -: 1786:	requires (__assignable<const _U1&, const _U2&>())
        -: 1787:	constexpr tuple&
        -: 1788:	operator=(const pair<_U1, _U2>& __u)
        -: 1789:	noexcept(__nothrow_assignable<const _U1&, const _U2&>())
        -: 1790:	{
        -: 1791:	  this->_M_head(*this) = __u.first;
        -: 1792:	  this->_M_tail(*this)._M_head(*this) = __u.second;
        -: 1793:	  return *this;
        -: 1794:	}
        -: 1795:
        -: 1796:      template<typename _U1, typename _U2>
        -: 1797:	requires (__assignable<_U1, _U2>())
        -: 1798:	constexpr tuple&
        -: 1799:	operator=(pair<_U1, _U2>&& __u)
        -: 1800:	noexcept(__nothrow_assignable<_U1, _U2>())
        -: 1801:	{
        -: 1802:	  this->_M_head(*this) = std::forward<_U1>(__u.first);
        -: 1803:	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second);
        -: 1804:	  return *this;
        -: 1805:	}
        -: 1806:
        -: 1807:#if __cpp_lib_ranges_zip // >= C++23
        -: 1808:      template<typename _U1, typename _U2>
        -: 1809:	requires (__const_assignable<const _U1&, const _U2>())
        -: 1810:	constexpr const tuple&
        -: 1811:	operator=(const pair<_U1, _U2>& __u) const
        -: 1812:	{
        -: 1813:	  this->_M_head(*this) = __u.first;
        -: 1814:	  this->_M_tail(*this)._M_head(*this) = __u.second;
        -: 1815:	  return *this;
        -: 1816:	}
        -: 1817:
        -: 1818:      template<typename _U1, typename _U2>
        -: 1819:	requires (__const_assignable<_U1, _U2>())
        -: 1820:	constexpr const tuple&
        -: 1821:	operator=(pair<_U1, _U2>&& __u) const
        -: 1822:	{
        -: 1823:	  this->_M_head(*this) = std::forward<_U1>(__u.first);
        -: 1824:	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second);
        -: 1825:	  return *this;
        -: 1826:	}
        -: 1827:#endif // C++23
        -: 1828:
        -: 1829:#if __cpp_lib_tuple_like // >= C++23
        -: 1830:      template<__eligible_tuple_like<tuple> _UTuple>
        -: 1831:	requires (__assignable_from_tuple_like<_UTuple>())
        -: 1832:	constexpr tuple&
        -: 1833:	operator=(_UTuple&& __u)
        -: 1834:	{
        -: 1835:	  this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
        -: 1836:	  return *this;
        -: 1837:	}
        -: 1838:
        -: 1839:      template<__eligible_tuple_like<tuple> _UTuple>
        -: 1840:	requires (__const_assignable_from_tuple_like<_UTuple>())
        -: 1841:	constexpr const tuple&
        -: 1842:	operator=(_UTuple&& __u) const
        -: 1843:	{
        -: 1844:	  this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
        -: 1845:	  return *this;
        -: 1846:	}
        -: 1847:
        -: 1848:      template<__tuple_like _UTuple>
        -: 1849:	requires (!__is_tuple_v<_UTuple>)
        -: 1850:	friend constexpr bool
        -: 1851:	operator==(const tuple& __t, const _UTuple& __u)
        -: 1852:	{
        -: 1853:	  static_assert(sizeof...(_Elements) == tuple_size_v<_UTuple>,
        -: 1854:	      "tuple objects can only be compared if they have equal sizes.");
        -: 1855:	  return [&]<size_t... _Is>(index_sequence<_Is...>) {
        -: 1856:	    return (bool(std::get<_Is>(__t) == std::get<_Is>(__u))
        -: 1857:		    && ...);
        -: 1858:	  }(index_sequence_for<_Elements...>{});
        -: 1859:	}
        -: 1860:
        -: 1861:      template<__tuple_like _UTuple,
        -: 1862:	       typename = make_index_sequence<tuple_size_v<_UTuple>>>
        -: 1863:	struct __tuple_like_common_comparison_category;
        -: 1864:
        -: 1865:      template<__tuple_like _UTuple, size_t... _Is>
        -: 1866:	requires requires
        -: 1867:	  { typename void_t<__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>; }
        -: 1868:	struct __tuple_like_common_comparison_category<_UTuple, index_sequence<_Is...>>
        -: 1869:	{
        -: 1870:	  using type = common_comparison_category_t
        -: 1871:	    <__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>;
        -: 1872:	};
        -: 1873:
        -: 1874:      template<__tuple_like _UTuple>
        -: 1875:	requires (!__is_tuple_v<_UTuple>)
        -: 1876:	friend constexpr typename __tuple_like_common_comparison_category<_UTuple>::type
        -: 1877:	operator<=>(const tuple& __t, const _UTuple& __u)
        -: 1878:	{
        -: 1879:	  using _Cat = typename __tuple_like_common_comparison_category<_UTuple>::type;
        -: 1880:	  return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Elements...>());
        -: 1881:	}
        -: 1882:#endif // C++23
        -: 1883:
        -: 1884:#else // ! (concepts && consteval)
        -: 1885:
        -: 1886:    private:
        -: 1887:      template<typename... _UElements>
        -: 1888:	static constexpr
        -: 1889:	__enable_if_t<sizeof...(_UElements) == sizeof...(_Elements), bool>
        -: 1890:	__assignable()
        -: 1891:	{ return __and_<is_assignable<_Elements&, _UElements>...>::value; }
        -: 1892:
        -: 1893:      // Condition for noexcept-specifier of an assignment operator.
        -: 1894:      template<typename... _UElements>
        -: 1895:	static constexpr bool __nothrow_assignable()
        -: 1896:	{
        -: 1897:	  return
        -: 1898:	    __and_<is_nothrow_assignable<_Elements&, _UElements>...>::value;
        -: 1899:	}
        -: 1900:
        -: 1901:    public:
        -: 1902:
        -: 1903:      _GLIBCXX20_CONSTEXPR
        -: 1904:      tuple&
        -: 1905:      operator=(__conditional_t<__assignable<const _Elements&...>(),
        -: 1906:				const tuple&,
        -: 1907:				const __nonesuch&> __in)
        -: 1908:      noexcept(__nothrow_assignable<const _Elements&...>())
        -: 1909:      {
        -: 1910:	this->_M_assign(__in);
        -: 1911:	return *this;
        -: 1912:      }
        -: 1913:
        -: 1914:      _GLIBCXX20_CONSTEXPR
        -: 1915:      tuple&
        -: 1916:      operator=(__conditional_t<__assignable<_Elements...>(),
        -: 1917:				tuple&&,
        -: 1918:				__nonesuch&&> __in)
        -: 1919:      noexcept(__nothrow_assignable<_Elements...>())
        -: 1920:      {
        -: 1921:	this->_M_assign(std::move(__in));
        -: 1922:	return *this;
        -: 1923:      }
        -: 1924:
        -: 1925:      template<typename... _UElements>
        -: 1926:	_GLIBCXX20_CONSTEXPR
        -: 1927:	__enable_if_t<__assignable<const _UElements&...>(), tuple&>
        -: 1928:	operator=(const tuple<_UElements...>& __in)
        -: 1929:	noexcept(__nothrow_assignable<const _UElements&...>())
        -: 1930:	{
        -: 1931:	  this->_M_assign(__in);
        -: 1932:	  return *this;
        -: 1933:	}
        -: 1934:
        -: 1935:      template<typename... _UElements>
        -: 1936:	_GLIBCXX20_CONSTEXPR
        -: 1937:	__enable_if_t<__assignable<_UElements...>(), tuple&>
        -: 1938:	operator=(tuple<_UElements...>&& __in)
        -: 1939:	noexcept(__nothrow_assignable<_UElements...>())
        -: 1940:	{
        -: 1941:	  this->_M_assign(std::move(__in));
        -: 1942:	  return *this;
        -: 1943:	}
        -: 1944:#endif // concepts && consteval
        -: 1945:
        -: 1946:      // tuple swap
        -: 1947:      _GLIBCXX20_CONSTEXPR
        -: 1948:      void
        -: 1949:      swap(tuple& __in)
        -: 1950:      noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
        -: 1951:      { _Inherited::_M_swap(__in); }
        -: 1952:
        -: 1953:#if __cpp_lib_ranges_zip // >= C++23
        -: 1954:      // As an extension, we constrain the const swap member function in order
        -: 1955:      // to continue accepting explicit instantiation of tuples whose elements
        -: 1956:      // are not all const swappable.  Without this constraint, such an
        -: 1957:      // explicit instantiation would also instantiate the ill-formed body of
        -: 1958:      // this function and yield a hard error.  This constraint shouldn't
        -: 1959:      // affect the behavior of valid programs.
        -: 1960:      constexpr void
        -: 1961:      swap(const tuple& __in) const
        -: 1962:      noexcept(__and_v<__is_nothrow_swappable<const _Elements>...>)
        -: 1963:      requires (is_swappable_v<const _Elements> && ...)
        -: 1964:      { _Inherited::_M_swap(__in); }
        -: 1965:#endif // C++23
        -: 1966:    };
        -: 1967:
        -: 1968:#if __cpp_deduction_guides >= 201606
        -: 1969:  template<typename... _UTypes>
        -: 1970:    tuple(_UTypes...) -> tuple<_UTypes...>;
        -: 1971:  template<typename _T1, typename _T2>
        -: 1972:    tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
        -: 1973:  template<typename _Alloc, typename... _UTypes>
        -: 1974:    tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
        -: 1975:  template<typename _Alloc, typename _T1, typename _T2>
        -: 1976:    tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
        -: 1977:  template<typename _Alloc, typename... _UTypes>
        -: 1978:    tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;
        -: 1979:#endif
        -: 1980:
        -: 1981:  // Explicit specialization, zero-element tuple.
        -: 1982:  template<>
        -: 1983:    class tuple<>
        -: 1984:    {
        -: 1985:    public:
        -: 1986:      _GLIBCXX20_CONSTEXPR
        -: 1987:      void swap(tuple&) noexcept { /* no-op */ }
        -: 1988:#if __cpp_lib_ranges_zip // >= C++23
        -: 1989:      constexpr void swap(const tuple&) const noexcept { /* no-op */ }
        -: 1990:#endif
        -: 1991:      // We need the default since we're going to define no-op
        -: 1992:      // allocator constructors.
        -: 1993:      tuple() = default;
        -: 1994:      // No-op allocator constructors.
        -: 1995:      template<typename _Alloc>
        -: 1996:	_GLIBCXX20_CONSTEXPR
        -: 1997:	tuple(allocator_arg_t, const _Alloc&) noexcept { }
        -: 1998:      template<typename _Alloc>
        -: 1999:	_GLIBCXX20_CONSTEXPR
        -: 2000:	tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
        -: 2001:    };
        -: 2002:
        -: 2003:#if !(__cpp_concepts && __cpp_consteval && __cpp_conditional_explicit) // !C++20
        -: 2004:  /// Partial specialization, 2-element tuple.
        -: 2005:  /// Includes construction and assignment from a pair.
        -: 2006:  template<typename _T1, typename _T2>
        -: 2007:    class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
        -: 2008:    {
        -: 2009:      typedef _Tuple_impl<0, _T1, _T2> _Inherited;
        -: 2010:
        -: 2011:      // Constraint for non-explicit default constructor
        -: 2012:      template<bool _Dummy, typename _U1, typename _U2>
        -: 2013:	using _ImplicitDefaultCtor = __enable_if_t<
        -: 2014:	  _TupleConstraints<_Dummy, _U1, _U2>::
        -: 2015:	    __is_implicitly_default_constructible(),
        -: 2016:	  bool>;
        -: 2017:
        -: 2018:      // Constraint for explicit default constructor
        -: 2019:      template<bool _Dummy, typename _U1, typename _U2>
        -: 2020:	using _ExplicitDefaultCtor = __enable_if_t<
        -: 2021:	  _TupleConstraints<_Dummy, _U1, _U2>::
        -: 2022:	    __is_explicitly_default_constructible(),
        -: 2023:	  bool>;
        -: 2024:
        -: 2025:      template<bool _Dummy>
        -: 2026:	using _TCC = _TupleConstraints<_Dummy, _T1, _T2>;
        -: 2027:
        -: 2028:      // Constraint for non-explicit constructors
        -: 2029:      template<bool _Cond, typename _U1, typename _U2>
        -: 2030:	using _ImplicitCtor = __enable_if_t<
        -: 2031:	  _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(),
        -: 2032:	  bool>;
        -: 2033:
        -: 2034:      // Constraint for non-explicit constructors
        -: 2035:      template<bool _Cond, typename _U1, typename _U2>
        -: 2036:	using _ExplicitCtor = __enable_if_t<
        -: 2037:	  _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(),
        -: 2038:	  bool>;
        -: 2039:
        -: 2040:      template<typename _U1, typename _U2>
        -: 2041:	static constexpr bool __assignable()
        -: 2042:	{
        -: 2043:	  return __and_<is_assignable<_T1&, _U1>,
        -: 2044:			is_assignable<_T2&, _U2>>::value;
        -: 2045:	}
        -: 2046:
        -: 2047:      template<typename _U1, typename _U2>
        -: 2048:	static constexpr bool __nothrow_assignable()
        -: 2049:	{
        -: 2050:	  return __and_<is_nothrow_assignable<_T1&, _U1>,
        -: 2051:			is_nothrow_assignable<_T2&, _U2>>::value;
        -: 2052:	}
        -: 2053:
        -: 2054:      template<typename _U1, typename _U2>
        -: 2055:	static constexpr bool __nothrow_constructible()
        -: 2056:	{
        -: 2057:	  return __and_<is_nothrow_constructible<_T1, _U1>,
        -: 2058:			    is_nothrow_constructible<_T2, _U2>>::value;
        -: 2059:	}
        -: 2060:
        -: 2061:      static constexpr bool __nothrow_default_constructible()
        -: 2062:      {
        -: 2063:	return __and_<is_nothrow_default_constructible<_T1>,
        -: 2064:		      is_nothrow_default_constructible<_T2>>::value;
        -: 2065:      }
        -: 2066:
        -: 2067:      template<typename _U1>
        -: 2068:	static constexpr bool __is_alloc_arg()
        -: 2069:	{ return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; }
        -: 2070:
        -: 2071:      /// @cond undocumented
        -: 2072:#undef __glibcxx_no_dangling_refs
        -: 2073:      // Error if construction from _U1 and _U2 would create a dangling ref.
        -: 2074:#if __has_builtin(__reference_constructs_from_temporary) \
        -: 2075:      && defined _GLIBCXX_DEBUG
        -: 2076:# define __glibcxx_no_dangling_refs(_U1, _U2) \
        -: 2077:  static_assert(!__reference_constructs_from_temporary(_T1, _U1) \
        -: 2078:	       && !__reference_constructs_from_temporary(_T2, _U2), \
        -: 2079:		"std::tuple constructor creates a dangling reference")
        -: 2080:#else
        -: 2081:# define __glibcxx_no_dangling_refs(_U1, _U2)
        -: 2082:#endif
        -: 2083:      /// @endcond
        -: 2084:
        -: 2085:    public:
        -: 2086:      template<bool _Dummy = true,
        -: 2087:	       _ImplicitDefaultCtor<_Dummy, _T1, _T2> = true>
        -: 2088:	constexpr
        -: 2089:	tuple()
        -: 2090:	noexcept(__nothrow_default_constructible())
        -: 2091:	: _Inherited() { }
        -: 2092:
        -: 2093:      template<bool _Dummy = true,
        -: 2094:	       _ExplicitDefaultCtor<_Dummy, _T1, _T2> = false>
        -: 2095:	explicit constexpr
        -: 2096:	tuple()
        -: 2097:	noexcept(__nothrow_default_constructible())
        -: 2098:	: _Inherited() { }
        -: 2099:
        -: 2100:      template<bool _Dummy = true,
        -: 2101:	       _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
        -: 2102:	constexpr
        -: 2103:	tuple(const _T1& __a1, const _T2& __a2)
        -: 2104:	noexcept(__nothrow_constructible<const _T1&, const _T2&>())
        -: 2105:	: _Inherited(__a1, __a2) { }
        -: 2106:
        -: 2107:      template<bool _Dummy = true,
        -: 2108:	       _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
        -: 2109:	explicit constexpr
        -: 2110:	tuple(const _T1& __a1, const _T2& __a2)
        -: 2111:	noexcept(__nothrow_constructible<const _T1&, const _T2&>())
        -: 2112:	: _Inherited(__a1, __a2) { }
        -: 2113:
        -: 2114:      template<typename _U1, typename _U2,
        -: 2115:	       _ImplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = true>
        -: 2116:	constexpr
        -: 2117:	tuple(_U1&& __a1, _U2&& __a2)
        -: 2118:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 2119:	: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2))
        -: 2120:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2121:
        -: 2122:      template<typename _U1, typename _U2,
        -: 2123:	       _ExplicitCtor<!__is_alloc_arg<_U1>(), _U1, _U2> = false>
        -: 2124:	explicit constexpr
        -: 2125:	tuple(_U1&& __a1, _U2&& __a2)
        -: 2126:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 2127:	: _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2))
        -: 2128:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2129:
        -: 2130:      constexpr tuple(const tuple&) = default;
        -: 2131:
        -: 2132:      constexpr tuple(tuple&&) = default;
        -: 2133:
        -: 2134:      template<typename _U1, typename _U2,
        -: 2135:	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
        -: 2136:	constexpr
        -: 2137:	tuple(const tuple<_U1, _U2>& __in)
        -: 2138:	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
        -: 2139:	: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
        -: 2140:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2141:
        -: 2142:      template<typename _U1, typename _U2,
        -: 2143:	       _ExplicitCtor<true, const _U1&, const _U2&> = false>
        -: 2144:	explicit constexpr
        -: 2145:	tuple(const tuple<_U1, _U2>& __in)
        -: 2146:	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
        -: 2147:	: _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
        -: 2148:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2149:
        -: 2150:      template<typename _U1, typename _U2,
        -: 2151:	       _ImplicitCtor<true, _U1, _U2> = true>
        -: 2152:	constexpr
        -: 2153:	tuple(tuple<_U1, _U2>&& __in)
        -: 2154:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 2155:	: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
        -: 2156:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2157:
        -: 2158:      template<typename _U1, typename _U2,
        -: 2159:	       _ExplicitCtor<true, _U1, _U2> = false>
        -: 2160:	explicit constexpr
        -: 2161:	tuple(tuple<_U1, _U2>&& __in)
        -: 2162:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 2163:	: _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
        -: 2164:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2165:
        -: 2166:      template<typename _U1, typename _U2,
        -: 2167:	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
        -: 2168:	constexpr
        -: 2169:	tuple(const pair<_U1, _U2>& __in)
        -: 2170:	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
        -: 2171:	: _Inherited(__in.first, __in.second)
        -: 2172:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2173:
        -: 2174:      template<typename _U1, typename _U2,
        -: 2175:	       _ExplicitCtor<true, const _U1&, const _U2&> = false>
        -: 2176:	explicit constexpr
        -: 2177:	tuple(const pair<_U1, _U2>& __in)
        -: 2178:	noexcept(__nothrow_constructible<const _U1&, const _U2&>())
        -: 2179:	: _Inherited(__in.first, __in.second)
        -: 2180:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2181:
        -: 2182:      template<typename _U1, typename _U2,
        -: 2183:	       _ImplicitCtor<true, _U1, _U2> = true>
        -: 2184:	constexpr
        -: 2185:	tuple(pair<_U1, _U2>&& __in)
        -: 2186:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 2187:	: _Inherited(std::forward<_U1>(__in.first),
        -: 2188:		     std::forward<_U2>(__in.second))
        -: 2189:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2190:
        -: 2191:      template<typename _U1, typename _U2,
        -: 2192:	       _ExplicitCtor<true, _U1, _U2> = false>
        -: 2193:	explicit constexpr
        -: 2194:	tuple(pair<_U1, _U2>&& __in)
        -: 2195:	noexcept(__nothrow_constructible<_U1, _U2>())
        -: 2196:	: _Inherited(std::forward<_U1>(__in.first),
        -: 2197:		     std::forward<_U2>(__in.second))
        -: 2198:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2199:
        -: 2200:      // Allocator-extended constructors.
        -: 2201:
        -: 2202:      template<typename _Alloc,
        -: 2203:	       _ImplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = true>
        -: 2204:	_GLIBCXX20_CONSTEXPR
        -: 2205:	tuple(allocator_arg_t __tag, const _Alloc& __a)
        -: 2206:	: _Inherited(__tag, __a) { }
        -: 2207:
        -: 2208:      template<typename _Alloc,
        -: 2209:	       _ExplicitDefaultCtor<is_object<_Alloc>::value, _T1, _T2> = false>
        -: 2210:	_GLIBCXX20_CONSTEXPR
        -: 2211:	explicit
        -: 2212:	tuple(allocator_arg_t __tag, const _Alloc& __a)
        -: 2213:	: _Inherited(__tag, __a) { }
        -: 2214:
        -: 2215:      template<typename _Alloc, bool _Dummy = true,
        -: 2216:	       _ImplicitCtor<_Dummy, const _T1&, const _T2&> = true>
        -: 2217:	_GLIBCXX20_CONSTEXPR
        -: 2218:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 2219:	      const _T1& __a1, const _T2& __a2)
        -: 2220:	: _Inherited(__tag, __a, __a1, __a2) { }
        -: 2221:
        -: 2222:      template<typename _Alloc, bool _Dummy = true,
        -: 2223:	       _ExplicitCtor<_Dummy, const _T1&, const _T2&> = false>
        -: 2224:	explicit
        -: 2225:	_GLIBCXX20_CONSTEXPR
        -: 2226:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 2227:	      const _T1& __a1, const _T2& __a2)
        -: 2228:	: _Inherited(__tag, __a, __a1, __a2) { }
        -: 2229:
        -: 2230:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2231:	       _ImplicitCtor<true, _U1, _U2> = true>
        -: 2232:	_GLIBCXX20_CONSTEXPR
        -: 2233:	tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2)
        -: 2234:	: _Inherited(__tag, __a, std::forward<_U1>(__a1),
        -: 2235:		     std::forward<_U2>(__a2))
        -: 2236:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2237:
        -: 2238:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2239:	       _ExplicitCtor<true, _U1, _U2> = false>
        -: 2240:	explicit
        -: 2241:	_GLIBCXX20_CONSTEXPR
        -: 2242:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 2243:	      _U1&& __a1, _U2&& __a2)
        -: 2244:	: _Inherited(__tag, __a, std::forward<_U1>(__a1),
        -: 2245:		     std::forward<_U2>(__a2))
        -: 2246:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2247:
        -: 2248:      template<typename _Alloc>
        -: 2249:	_GLIBCXX20_CONSTEXPR
        -: 2250:	tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
        -: 2251:	: _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
        -: 2252:
        -: 2253:      template<typename _Alloc>
        -: 2254:	_GLIBCXX20_CONSTEXPR
        -: 2255:	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
        -: 2256:	: _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
        -: 2257:
        -: 2258:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2259:	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
        -: 2260:	_GLIBCXX20_CONSTEXPR
        -: 2261:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 2262:	      const tuple<_U1, _U2>& __in)
        -: 2263:	: _Inherited(__tag, __a,
        -: 2264:		     static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
        -: 2265:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2266:
        -: 2267:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2268:	       _ExplicitCtor<true, const _U1&, const _U2&> = false>
        -: 2269:	explicit
        -: 2270:	_GLIBCXX20_CONSTEXPR
        -: 2271:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 2272:	      const tuple<_U1, _U2>& __in)
        -: 2273:	: _Inherited(__tag, __a,
        -: 2274:		     static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
        -: 2275:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2276:
        -: 2277:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2278:	       _ImplicitCtor<true, _U1, _U2> = true>
        -: 2279:	_GLIBCXX20_CONSTEXPR
        -: 2280:	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
        -: 2281:	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
        -: 2282:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2283:
        -: 2284:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2285:	       _ExplicitCtor<true, _U1, _U2> = false>
        -: 2286:	explicit
        -: 2287:	_GLIBCXX20_CONSTEXPR
        -: 2288:	tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
        -: 2289:	: _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
        -: 2290:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2291:
        -: 2292:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2293:	       _ImplicitCtor<true, const _U1&, const _U2&> = true>
        -: 2294:	_GLIBCXX20_CONSTEXPR
        -: 2295:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 2296:	      const pair<_U1, _U2>& __in)
        -: 2297:	: _Inherited(__tag, __a, __in.first, __in.second)
        -: 2298:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2299:
        -: 2300:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2301:	       _ExplicitCtor<true, const _U1&, const _U2&> = false>
        -: 2302:	explicit
        -: 2303:	_GLIBCXX20_CONSTEXPR
        -: 2304:	tuple(allocator_arg_t __tag, const _Alloc& __a,
        -: 2305:	      const pair<_U1, _U2>& __in)
        -: 2306:	: _Inherited(__tag, __a, __in.first, __in.second)
        -: 2307:	{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
        -: 2308:
        -: 2309:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2310:	       _ImplicitCtor<true, _U1, _U2> = true>
        -: 2311:	_GLIBCXX20_CONSTEXPR
        -: 2312:	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
        -: 2313:	: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
        -: 2314:		     std::forward<_U2>(__in.second))
        -: 2315:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2316:
        -: 2317:      template<typename _Alloc, typename _U1, typename _U2,
        -: 2318:	       _ExplicitCtor<true, _U1, _U2> = false>
        -: 2319:	explicit
        -: 2320:	_GLIBCXX20_CONSTEXPR
        -: 2321:	tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
        -: 2322:	: _Inherited(__tag, __a, std::forward<_U1>(__in.first),
        -: 2323:		     std::forward<_U2>(__in.second))
        -: 2324:	{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
        -: 2325:
        -: 2326:      // Tuple assignment.
        -: 2327:
        -: 2328:      _GLIBCXX20_CONSTEXPR
        -: 2329:      tuple&
        -: 2330:      operator=(__conditional_t<__assignable<const _T1&, const _T2&>(),
        -: 2331:				const tuple&,
        -: 2332:				const __nonesuch&> __in)
        -: 2333:      noexcept(__nothrow_assignable<const _T1&, const _T2&>())
        -: 2334:      {
        -: 2335:	this->_M_assign(__in);
        -: 2336:	return *this;
        -: 2337:      }
        -: 2338:
        -: 2339:      _GLIBCXX20_CONSTEXPR
        -: 2340:      tuple&
        -: 2341:      operator=(__conditional_t<__assignable<_T1, _T2>(),
        -: 2342:				tuple&&,
        -: 2343:				__nonesuch&&> __in)
        -: 2344:      noexcept(__nothrow_assignable<_T1, _T2>())
        -: 2345:      {
        -: 2346:	this->_M_assign(std::move(__in));
        -: 2347:	return *this;
        -: 2348:      }
        -: 2349:
        -: 2350:      template<typename _U1, typename _U2>
        -: 2351:	_GLIBCXX20_CONSTEXPR
        -: 2352:	__enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
        -: 2353:	operator=(const tuple<_U1, _U2>& __in)
        -: 2354:	noexcept(__nothrow_assignable<const _U1&, const _U2&>())
        -: 2355:	{
        -: 2356:	  this->_M_assign(__in);
        -: 2357:	  return *this;
        -: 2358:	}
        -: 2359:
        -: 2360:      template<typename _U1, typename _U2>
        -: 2361:	_GLIBCXX20_CONSTEXPR
        -: 2362:	__enable_if_t<__assignable<_U1, _U2>(), tuple&>
        -: 2363:	operator=(tuple<_U1, _U2>&& __in)
        -: 2364:	noexcept(__nothrow_assignable<_U1, _U2>())
        -: 2365:	{
        -: 2366:	  this->_M_assign(std::move(__in));
        -: 2367:	  return *this;
        -: 2368:	}
        -: 2369:
        -: 2370:      template<typename _U1, typename _U2>
        -: 2371:	_GLIBCXX20_CONSTEXPR
        -: 2372:	__enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
        -: 2373:	operator=(const pair<_U1, _U2>& __in)
        -: 2374:	noexcept(__nothrow_assignable<const _U1&, const _U2&>())
        -: 2375:	{
        -: 2376:	  this->_M_head(*this) = __in.first;
        -: 2377:	  this->_M_tail(*this)._M_head(*this) = __in.second;
        -: 2378:	  return *this;
        -: 2379:	}
        -: 2380:
        -: 2381:      template<typename _U1, typename _U2>
        -: 2382:	_GLIBCXX20_CONSTEXPR
        -: 2383:	__enable_if_t<__assignable<_U1, _U2>(), tuple&>
        -: 2384:	operator=(pair<_U1, _U2>&& __in)
        -: 2385:	noexcept(__nothrow_assignable<_U1, _U2>())
        -: 2386:	{
        -: 2387:	  this->_M_head(*this) = std::forward<_U1>(__in.first);
        -: 2388:	  this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
        -: 2389:	  return *this;
        -: 2390:	}
        -: 2391:
        -: 2392:      _GLIBCXX20_CONSTEXPR
        -: 2393:      void
        -: 2394:      swap(tuple& __in)
        -: 2395:      noexcept(__and_<__is_nothrow_swappable<_T1>,
        -: 2396:		      __is_nothrow_swappable<_T2>>::value)
        -: 2397:      { _Inherited::_M_swap(__in); }
        -: 2398:    };
        -: 2399:#endif // concepts && conditional_explicit
        -: 2400:
        -: 2401:  /// class tuple_size
        -: 2402:  template<typename... _Elements>
        -: 2403:    struct tuple_size<tuple<_Elements...>>
        -: 2404:    : public integral_constant<size_t, sizeof...(_Elements)> { };
        -: 2405:
        -: 2406:#if __cplusplus >= 201703L
        -: 2407:  template<typename... _Types>
        -: 2408:    inline constexpr size_t tuple_size_v<tuple<_Types...>>
        -: 2409:      = sizeof...(_Types);
        -: 2410:
        -: 2411:  template<typename... _Types>
        -: 2412:    inline constexpr size_t tuple_size_v<const tuple<_Types...>>
        -: 2413:      = sizeof...(_Types);
        -: 2414:#endif
        -: 2415:
        -: 2416:  /// Trait to get the Ith element type from a tuple.
        -: 2417:  template<size_t __i, typename... _Types>
        -: 2418:    struct tuple_element<__i, tuple<_Types...>>
        -: 2419:    {
        -: 2420:      static_assert(__i < sizeof...(_Types), "tuple index must be in range");
        -: 2421:
        -: 2422:      using type = typename _Nth_type<__i, _Types...>::type;
        -: 2423:    };
        -: 2424:
        -: 2425:  template<size_t __i, typename _Head, typename... _Tail>
        -: 2426:    constexpr _Head&
        -: 2427:    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
      21*: 2428:    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
        -: 2429:
        -: 2430:  template<size_t __i, typename _Head, typename... _Tail>
        -: 2431:    constexpr const _Head&
        -: 2432:    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
        -: 2433:    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
        -: 2434:
        -: 2435:  // Deleted overload to improve diagnostics for invalid indices
        -: 2436:  template<size_t __i, typename... _Types>
        -: 2437:    __enable_if_t<(__i >= sizeof...(_Types))>
        -: 2438:    __get_helper(const tuple<_Types...>&) = delete;
        -: 2439:
        -: 2440:  /// Return a reference to the ith element of a tuple.
        -: 2441:  template<size_t __i, typename... _Elements>
        -: 2442:    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
        -: 2443:    get(tuple<_Elements...>& __t) noexcept
      21*: 2444:    { return std::__get_helper<__i>(__t); }
    %%%%%: 2444-block 5
branch  0 never executed (fallthrough)
branch  1 never executed
    $$$$$: 2444-block 9
branch  2 never executed (fallthrough)
branch  3 never executed
    %%%%%: 2444-block 5
branch  4 never executed (fallthrough)
branch  5 never executed
    $$$$$: 2444-block 9
branch  6 never executed (fallthrough)
branch  7 never executed
    %%%%%: 2444-block 5
branch  8 never executed (fallthrough)
branch  9 never executed
    $$$$$: 2444-block 9
branch 10 never executed (fallthrough)
branch 11 never executed
    %%%%%: 2444-block 5
branch 12 never executed (fallthrough)
branch 13 never executed
    $$$$$: 2444-block 9
branch 14 never executed (fallthrough)
branch 15 never executed
    %%%%%: 2444-block 5
branch 16 never executed (fallthrough)
branch 17 never executed
    $$$$$: 2444-block 9
branch 18 never executed (fallthrough)
branch 19 never executed
    %%%%%: 2444-block 2
branch 20 never executed (fallthrough)
branch 21 never executed
    %%%%%: 2444-block 3
вызов  22 ни разу не исполнялся
       21: 2444-block 2
переход 23 выполнен 0 (fallthrough)
переход 24 выполнен 21
    %%%%%: 2444-block 3
вызов  25 ни разу не исполнялся
branch 26 never executed (fallthrough)
branch 27 never executed
    $$$$$: 2444-block 27
branch 28 never executed (fallthrough)
branch 29 never executed
branch 30 never executed (fallthrough)
branch 31 never executed
    $$$$$: 2444-block 27
branch 32 never executed (fallthrough)
branch 33 never executed
branch 34 never executed (fallthrough)
branch 35 never executed
    $$$$$: 2444-block 23
branch 36 never executed (fallthrough)
branch 37 never executed
branch 38 never executed (fallthrough)
branch 39 never executed
    $$$$$: 2444-block 22
branch 40 never executed (fallthrough)
branch 41 never executed
branch 42 never executed (fallthrough)
branch 43 never executed
    $$$$$: 2444-block 23
branch 44 never executed (fallthrough)
branch 45 never executed
branch 46 never executed (fallthrough)
branch 47 never executed
    $$$$$: 2444-block 22
branch 48 never executed (fallthrough)
branch 49 never executed
branch 50 never executed (fallthrough)
branch 51 never executed
    $$$$$: 2444-block 29
branch 52 never executed (fallthrough)
branch 53 never executed
branch 54 never executed (fallthrough)
branch 55 never executed
    $$$$$: 2444-block 29
branch 56 never executed (fallthrough)
branch 57 never executed
branch 58 never executed (fallthrough)
branch 59 never executed
    $$$$$: 2444-block 24
branch 60 never executed (fallthrough)
branch 61 never executed
branch 62 never executed (fallthrough)
branch 63 never executed
    $$$$$: 2444-block 24
branch 64 never executed (fallthrough)
branch 65 never executed
branch 66 never executed (fallthrough)
branch 67 never executed
    $$$$$: 2444-block 24
branch 68 never executed (fallthrough)
branch 69 never executed
branch 70 never executed (fallthrough)
branch 71 never executed
    $$$$$: 2444-block 22
branch 72 never executed (fallthrough)
branch 73 never executed
branch 74 never executed (fallthrough)
branch 75 never executed
    $$$$$: 2444-block 22
branch 76 never executed (fallthrough)
branch 77 never executed
branch 78 never executed (fallthrough)
branch 79 never executed
    $$$$$: 2444-block 22
branch 80 never executed (fallthrough)
branch 81 never executed
branch 82 never executed (fallthrough)
branch 83 never executed
    $$$$$: 2444-block 28
branch 84 never executed (fallthrough)
branch 85 never executed
branch 86 never executed (fallthrough)
branch 87 never executed
    $$$$$: 2444-block 25
branch 88 never executed (fallthrough)
branch 89 never executed
branch 90 never executed (fallthrough)
branch 91 never executed
    $$$$$: 2444-block 24
branch 92 never executed (fallthrough)
branch 93 never executed
branch 94 never executed (fallthrough)
branch 95 never executed
    $$$$$: 2444-block 25
branch 96 never executed (fallthrough)
branch 97 never executed
branch 98 never executed (fallthrough)
branch 99 never executed
    $$$$$: 2444-block 25
branch 100 never executed (fallthrough)
branch 101 never executed
branch 102 never executed (fallthrough)
branch 103 never executed
    $$$$$: 2444-block 24
branch 104 never executed (fallthrough)
branch 105 never executed
branch 106 never executed (fallthrough)
branch 107 never executed
    $$$$$: 2444-block 24
branch 108 never executed (fallthrough)
branch 109 never executed
вызов  110 ни разу не исполнялся
        -: 2445:
        -: 2446:  /// Return a const reference to the ith element of a const tuple.
        -: 2447:  template<size_t __i, typename... _Elements>
        -: 2448:    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
        -: 2449:    get(const tuple<_Elements...>& __t) noexcept
    #####: 2450:    { return std::__get_helper<__i>(__t); }
вызов   0 ни разу не исполнялся
branch  1 never executed (fallthrough)
branch  2 never executed (throw)
вызов   3 ни разу не исполнялся
branch  4 never executed (fallthrough)
branch  5 never executed (throw)
вызов   6 ни разу не исполнялся
branch  7 never executed (fallthrough)
branch  8 never executed (throw)
вызов   9 ни разу не исполнялся
branch 10 never executed (fallthrough)
branch 11 never executed (throw)
    %%%%%: 2450-block 3
вызов  12 ни разу не исполнялся
    %%%%%: 2450-block 4
вызов  13 ни разу не исполнялся
    %%%%%: 2450-block 8
branch 14 never executed (fallthrough)
branch 15 never executed
    %%%%%: 2450-block 9
    %%%%%: 2450-block 8
branch 16 never executed (fallthrough)
branch 17 never executed
    %%%%%: 2450-block 9
    %%%%%: 2450-block 8
branch 18 never executed (fallthrough)
branch 19 never executed
    %%%%%: 2450-block 9
    %%%%%: 2450-block 7
branch 20 never executed (fallthrough)
branch 21 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 8
branch 22 never executed (fallthrough)
branch 23 never executed
    %%%%%: 2450-block 9
    %%%%%: 2450-block 7
branch 24 never executed (fallthrough)
branch 25 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 10
branch 26 never executed (fallthrough)
branch 27 never executed
    %%%%%: 2450-block 11
    %%%%%: 2450-block 10
branch 28 never executed (fallthrough)
branch 29 never executed
    %%%%%: 2450-block 11
    %%%%%: 2450-block 7
branch 30 never executed (fallthrough)
branch 31 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 7
branch 32 never executed (fallthrough)
branch 33 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 7
branch 34 never executed (fallthrough)
branch 35 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 7
branch 36 never executed (fallthrough)
branch 37 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 7
branch 38 never executed (fallthrough)
branch 39 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 7
branch 40 never executed (fallthrough)
branch 41 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 11
branch 42 never executed (fallthrough)
branch 43 never executed
    %%%%%: 2450-block 12
    %%%%%: 2450-block 8
branch 44 never executed (fallthrough)
branch 45 never executed
    %%%%%: 2450-block 9
    %%%%%: 2450-block 7
branch 46 never executed (fallthrough)
branch 47 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 8
branch 48 never executed (fallthrough)
branch 49 never executed
    %%%%%: 2450-block 9
    %%%%%: 2450-block 8
branch 50 never executed (fallthrough)
branch 51 never executed
    %%%%%: 2450-block 9
    %%%%%: 2450-block 7
branch 52 never executed (fallthrough)
branch 53 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 7
branch 54 never executed (fallthrough)
branch 55 never executed
    %%%%%: 2450-block 8
    %%%%%: 2450-block 2
branch 56 never executed (fallthrough)
branch 57 never executed
    %%%%%: 2450-block 7
вызов  58 ни разу не исполнялся
        -: 2451:
        -: 2452:  /// Return an rvalue reference to the ith element of a tuple rvalue.
        -: 2453:  template<size_t __i, typename... _Elements>
        -: 2454:    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
        -: 2455:    get(tuple<_Elements...>&& __t) noexcept
        -: 2456:    {
        -: 2457:      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
        -: 2458:      return std::forward<__element_type>(std::__get_helper<__i>(__t));
        -: 2459:    }
        -: 2460:
        -: 2461:  /// Return a const rvalue reference to the ith element of a const tuple rvalue.
        -: 2462:  template<size_t __i, typename... _Elements>
        -: 2463:    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
        -: 2464:    get(const tuple<_Elements...>&& __t) noexcept
        -: 2465:    {
        -: 2466:      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
        -: 2467:      return std::forward<const __element_type>(std::__get_helper<__i>(__t));
        -: 2468:    }
        -: 2469:
        -: 2470:  /// @cond undocumented
        -: 2471:  // Deleted overload chosen for invalid indices.
        -: 2472:  template<size_t __i, typename... _Elements>
        -: 2473:    constexpr __enable_if_t<(__i >= sizeof...(_Elements))>
        -: 2474:    get(const tuple<_Elements...>&) = delete;
        -: 2475:  /// @endcond
        -: 2476:
        -: 2477:#ifdef __cpp_lib_tuples_by_type // C++ >= 14
        -: 2478:  /// Return a reference to the unique element of type _Tp of a tuple.
        -: 2479:  template <typename _Tp, typename... _Types>
        -: 2480:    constexpr _Tp&
        -: 2481:    get(tuple<_Types...>& __t) noexcept
        -: 2482:    {
        -: 2483:      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
        -: 2484:      static_assert(__idx < sizeof...(_Types),
        -: 2485:	  "the type T in std::get<T> must occur exactly once in the tuple");
        -: 2486:      return std::__get_helper<__idx>(__t);
        -: 2487:    }
        -: 2488:
        -: 2489:  /// Return a reference to the unique element of type _Tp of a tuple rvalue.
        -: 2490:  template <typename _Tp, typename... _Types>
        -: 2491:    constexpr _Tp&&
        -: 2492:    get(tuple<_Types...>&& __t) noexcept
        -: 2493:    {
        -: 2494:      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
        -: 2495:      static_assert(__idx < sizeof...(_Types),
        -: 2496:	  "the type T in std::get<T> must occur exactly once in the tuple");
        -: 2497:      return std::forward<_Tp>(std::__get_helper<__idx>(__t));
        -: 2498:    }
        -: 2499:
        -: 2500:  /// Return a const reference to the unique element of type _Tp of a tuple.
        -: 2501:  template <typename _Tp, typename... _Types>
        -: 2502:    constexpr const _Tp&
        -: 2503:    get(const tuple<_Types...>& __t) noexcept
        -: 2504:    {
        -: 2505:      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
        -: 2506:      static_assert(__idx < sizeof...(_Types),
        -: 2507:	  "the type T in std::get<T> must occur exactly once in the tuple");
        -: 2508:      return std::__get_helper<__idx>(__t);
        -: 2509:    }
        -: 2510:
        -: 2511:  /// Return a const reference to the unique element of type _Tp of
        -: 2512:  /// a const tuple rvalue.
        -: 2513:  template <typename _Tp, typename... _Types>
        -: 2514:    constexpr const _Tp&&
        -: 2515:    get(const tuple<_Types...>&& __t) noexcept
        -: 2516:    {
        -: 2517:      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
        -: 2518:      static_assert(__idx < sizeof...(_Types),
        -: 2519:	  "the type T in std::get<T> must occur exactly once in the tuple");
        -: 2520:      return std::forward<const _Tp>(std::__get_helper<__idx>(__t));
        -: 2521:    }
        -: 2522:#endif
        -: 2523:
        -: 2524:  // This class performs the comparison operations on tuples
        -: 2525:  template<typename _Tp, typename _Up, size_t __i, size_t __size>
        -: 2526:    struct __tuple_compare
        -: 2527:    {
        -: 2528:      static constexpr bool
        -: 2529:      __eq(const _Tp& __t, const _Up& __u)
        -: 2530:      {
        -: 2531:	return bool(std::get<__i>(__t) == std::get<__i>(__u))
        -: 2532:	  && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
        -: 2533:      }
        -: 2534:
        -: 2535:      static constexpr bool
        -: 2536:      __less(const _Tp& __t, const _Up& __u)
        -: 2537:      {
        -: 2538:	return bool(std::get<__i>(__t) < std::get<__i>(__u))
        -: 2539:	  || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
        -: 2540:	      && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
        -: 2541:      }
        -: 2542:    };
        -: 2543:
        -: 2544:  template<typename _Tp, typename _Up, size_t __size>
        -: 2545:    struct __tuple_compare<_Tp, _Up, __size, __size>
        -: 2546:    {
        -: 2547:      static constexpr bool
        -: 2548:      __eq(const _Tp&, const _Up&) { return true; }
        -: 2549:
        -: 2550:      static constexpr bool
        -: 2551:      __less(const _Tp&, const _Up&) { return false; }
        -: 2552:    };
        -: 2553:
        -: 2554:  template<typename... _TElements, typename... _UElements>
        -: 2555:    constexpr bool
        -: 2556:    operator==(const tuple<_TElements...>& __t,
        -: 2557:	       const tuple<_UElements...>& __u)
        -: 2558:    {
        -: 2559:      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
        -: 2560:	  "tuple objects can only be compared if they have equal sizes.");
        -: 2561:      using __compare = __tuple_compare<tuple<_TElements...>,
        -: 2562:					tuple<_UElements...>,
        -: 2563:					0, sizeof...(_TElements)>;
        -: 2564:      return __compare::__eq(__t, __u);
        -: 2565:    }
        -: 2566:
        -: 2567:#if __cpp_lib_three_way_comparison
        -: 2568:  template<typename _Cat, typename _Tp, typename _Up>
        -: 2569:    constexpr _Cat
        -: 2570:    __tuple_cmp(const _Tp&, const _Up&, index_sequence<>)
        -: 2571:    { return _Cat::equivalent; }
        -: 2572:
        -: 2573:  template<typename _Cat, typename _Tp, typename _Up,
        -: 2574:	   size_t _Idx0, size_t... _Idxs>
        -: 2575:    constexpr _Cat
        -: 2576:    __tuple_cmp(const _Tp& __t, const _Up& __u,
        -: 2577:		index_sequence<_Idx0, _Idxs...>)
        -: 2578:    {
        -: 2579:      auto __c
        -: 2580:	= __detail::__synth3way(std::get<_Idx0>(__t), std::get<_Idx0>(__u));
        -: 2581:      if (__c != 0)
        -: 2582:	return __c;
        -: 2583:      return std::__tuple_cmp<_Cat>(__t, __u, index_sequence<_Idxs...>());
        -: 2584:    }
        -: 2585:
        -: 2586:  template<typename... _Tps, typename... _Ups>
        -: 2587:    constexpr
        -: 2588:    common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>
        -: 2589:    operator<=>(const tuple<_Tps...>& __t, const tuple<_Ups...>& __u)
        -: 2590:    {
        -: 2591:      using _Cat
        -: 2592:	= common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>;
        -: 2593:      return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>());
        -: 2594:    }
        -: 2595:#else
        -: 2596:  template<typename... _TElements, typename... _UElements>
        -: 2597:    constexpr bool
        -: 2598:    operator<(const tuple<_TElements...>& __t,
        -: 2599:	      const tuple<_UElements...>& __u)
        -: 2600:    {
        -: 2601:      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
        -: 2602:	  "tuple objects can only be compared if they have equal sizes.");
        -: 2603:      using __compare = __tuple_compare<tuple<_TElements...>,
        -: 2604:					tuple<_UElements...>,
        -: 2605:					0, sizeof...(_TElements)>;
        -: 2606:      return __compare::__less(__t, __u);
        -: 2607:    }
        -: 2608:
        -: 2609:  template<typename... _TElements, typename... _UElements>
        -: 2610:    constexpr bool
        -: 2611:    operator!=(const tuple<_TElements...>& __t,
        -: 2612:	       const tuple<_UElements...>& __u)
        -: 2613:    { return !(__t == __u); }
        -: 2614:
        -: 2615:  template<typename... _TElements, typename... _UElements>
        -: 2616:    constexpr bool
        -: 2617:    operator>(const tuple<_TElements...>& __t,
        -: 2618:	      const tuple<_UElements...>& __u)
        -: 2619:    { return __u < __t; }
        -: 2620:
        -: 2621:  template<typename... _TElements, typename... _UElements>
        -: 2622:    constexpr bool
        -: 2623:    operator<=(const tuple<_TElements...>& __t,
        -: 2624:	       const tuple<_UElements...>& __u)
        -: 2625:    { return !(__u < __t); }
        -: 2626:
        -: 2627:  template<typename... _TElements, typename... _UElements>
        -: 2628:    constexpr bool
        -: 2629:    operator>=(const tuple<_TElements...>& __t,
        -: 2630:	       const tuple<_UElements...>& __u)
        -: 2631:    { return !(__t < __u); }
        -: 2632:#endif // three_way_comparison
        -: 2633:
        -: 2634:  // NB: DR 705.
        -: 2635:  /// Create a tuple containing copies of the arguments
        -: 2636:  template<typename... _Elements>
        -: 2637:    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
        -: 2638:    make_tuple(_Elements&&... __args)
        -: 2639:    {
        -: 2640:      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
        -: 2641:	__result_type;
        -: 2642:      return __result_type(std::forward<_Elements>(__args)...);
        -: 2643:    }
        -: 2644:
        -: 2645:  // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -: 2646:  // 2275. Why is forward_as_tuple not constexpr?
        -: 2647:  /// Create a tuple of lvalue or rvalue references to the arguments
        -: 2648:  template<typename... _Elements>
        -: 2649:    constexpr tuple<_Elements&&...>
        -: 2650:    forward_as_tuple(_Elements&&... __args) noexcept
        -: 2651:    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
        -: 2652:
        -: 2653:  /// @cond undocumented
        -: 2654:  template<size_t, typename, typename, size_t>
        -: 2655:    struct __make_tuple_impl;
        -: 2656:
        -: 2657:  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
        -: 2658:    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
        -: 2659:    : __make_tuple_impl<_Idx + 1,
        -: 2660:			tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
        -: 2661:			_Tuple, _Nm>
        -: 2662:    { };
        -: 2663:
        -: 2664:  template<size_t _Nm, typename _Tuple, typename... _Tp>
        -: 2665:    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
        -: 2666:    {
        -: 2667:      typedef tuple<_Tp...> __type;
        -: 2668:    };
        -: 2669:
        -: 2670:  template<typename _Tuple>
        -: 2671:    struct __do_make_tuple
        -: 2672:    : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
        -: 2673:    { };
        -: 2674:
        -: 2675:  // Returns the std::tuple equivalent of a tuple-like type.
        -: 2676:  template<typename _Tuple>
        -: 2677:    struct __make_tuple
        -: 2678:    : public __do_make_tuple<__remove_cvref_t<_Tuple>>
        -: 2679:    { };
        -: 2680:
        -: 2681:  // Combines several std::tuple's into a single one.
        -: 2682:  template<typename...>
        -: 2683:    struct __combine_tuples;
        -: 2684:
        -: 2685:  template<>
        -: 2686:    struct __combine_tuples<>
        -: 2687:    {
        -: 2688:      typedef tuple<> __type;
        -: 2689:    };
        -: 2690:
        -: 2691:  template<typename... _Ts>
        -: 2692:    struct __combine_tuples<tuple<_Ts...>>
        -: 2693:    {
        -: 2694:      typedef tuple<_Ts...> __type;
        -: 2695:    };
        -: 2696:
        -: 2697:  template<typename... _T1s, typename... _T2s, typename... _Rem>
        -: 2698:    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
        -: 2699:    {
        -: 2700:      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
        -: 2701:					_Rem...>::__type __type;
        -: 2702:    };
        -: 2703:
        -: 2704:  // Computes the result type of tuple_cat given a set of tuple-like types.
        -: 2705:  template<typename... _Tpls>
        -: 2706:    struct __tuple_cat_result
        -: 2707:    {
        -: 2708:      typedef typename __combine_tuples
        -: 2709:        <typename __make_tuple<_Tpls>::__type...>::__type __type;
        -: 2710:    };
        -: 2711:
        -: 2712:  // Helper to determine the index set for the first tuple-like
        -: 2713:  // type of a given set.
        -: 2714:  template<typename...>
        -: 2715:    struct __make_1st_indices;
        -: 2716:
        -: 2717:  template<>
        -: 2718:    struct __make_1st_indices<>
        -: 2719:    {
        -: 2720:      typedef _Index_tuple<> __type;
        -: 2721:    };
        -: 2722:
        -: 2723:  template<typename _Tp, typename... _Tpls>
        -: 2724:    struct __make_1st_indices<_Tp, _Tpls...>
        -: 2725:    {
        -: 2726:      typedef typename _Build_index_tuple<tuple_size<
        -: 2727:	typename remove_reference<_Tp>::type>::value>::__type __type;
        -: 2728:    };
        -: 2729:
        -: 2730:  // Performs the actual concatenation by step-wise expanding tuple-like
        -: 2731:  // objects into the elements,  which are finally forwarded into the
        -: 2732:  // result tuple.
        -: 2733:  template<typename _Ret, typename _Indices, typename... _Tpls>
        -: 2734:    struct __tuple_concater;
        -: 2735:
        -: 2736:  template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls>
        -: 2737:    struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...>
        -: 2738:    {
        -: 2739:      template<typename... _Us>
        -: 2740:        static constexpr _Ret
        -: 2741:        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
        -: 2742:        {
        -: 2743:	  typedef typename __make_1st_indices<_Tpls...>::__type __idx;
        -: 2744:	  typedef __tuple_concater<_Ret, __idx, _Tpls...>      __next;
        -: 2745:	  return __next::_S_do(std::forward<_Tpls>(__tps)...,
        -: 2746:			       std::forward<_Us>(__us)...,
        -: 2747:			       std::get<_Is>(std::forward<_Tp>(__tp))...);
        -: 2748:	}
        -: 2749:    };
        -: 2750:
        -: 2751:  template<typename _Ret>
        -: 2752:    struct __tuple_concater<_Ret, _Index_tuple<>>
        -: 2753:    {
        -: 2754:      template<typename... _Us>
        -: 2755:	static constexpr _Ret
        -: 2756:	_S_do(_Us&&... __us)
        -: 2757:        {
        -: 2758:	  return _Ret(std::forward<_Us>(__us)...);
        -: 2759:	}
        -: 2760:    };
        -: 2761:
        -: 2762:  template<typename... _Tps>
        -: 2763:    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
        -: 2764:    { };
        -: 2765:  /// @endcond
        -: 2766:
        -: 2767:  /// Create a `tuple` containing all elements from multiple tuple-like objects
        -: 2768:#if __cpp_lib_tuple_like // >= C++23
        -: 2769:  template<__tuple_like... _Tpls>
        -: 2770:#else
        -: 2771:  template<typename... _Tpls, typename = typename
        -: 2772:           enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
        -: 2773:#endif
        -: 2774:    constexpr auto
        -: 2775:    tuple_cat(_Tpls&&... __tpls)
        -: 2776:    -> typename __tuple_cat_result<_Tpls...>::__type
        -: 2777:    {
        -: 2778:      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
        -: 2779:      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
        -: 2780:      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
        -: 2781:      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
        -: 2782:    }
        -: 2783:
        -: 2784:  // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -: 2785:  // 2301. Why is tie not constexpr?
        -: 2786:  /// Return a tuple of lvalue references bound to the arguments
        -: 2787:  template<typename... _Elements>
        -: 2788:    constexpr tuple<_Elements&...>
        -: 2789:    tie(_Elements&... __args) noexcept
        -: 2790:    { return tuple<_Elements&...>(__args...); }
        -: 2791:
        -: 2792:  /// Exchange the values of two tuples
        -: 2793:  template<typename... _Elements>
        -: 2794:    _GLIBCXX20_CONSTEXPR
        -: 2795:    inline
        -: 2796:#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
        -: 2797:    // Constrained free swap overload, see p0185r1
        -: 2798:    typename enable_if<__and_<__is_swappable<_Elements>...>::value
        -: 2799:      >::type
        -: 2800:#else
        -: 2801:    void
        -: 2802:#endif
        -: 2803:    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
        -: 2804:    noexcept(noexcept(__x.swap(__y)))
        -: 2805:    { __x.swap(__y); }
        -: 2806:
        -: 2807:#if __cpp_lib_ranges_zip // >= C++23
        -: 2808:  template<typename... _Elements>
        -: 2809:    requires (is_swappable_v<const _Elements> && ...)
        -: 2810:    constexpr void
        -: 2811:    swap(const tuple<_Elements...>& __x, const tuple<_Elements...>& __y)
        -: 2812:    noexcept(noexcept(__x.swap(__y)))
        -: 2813:    { __x.swap(__y); }
        -: 2814:#endif // C++23
        -: 2815:
        -: 2816:#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
        -: 2817:  /// Exchange the values of two const tuples (if const elements can be swapped)
        -: 2818:  template<typename... _Elements>
        -: 2819:    _GLIBCXX20_CONSTEXPR
        -: 2820:    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
        -: 2821:    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;
        -: 2822:#endif
        -: 2823:
        -: 2824:  // A class (and instance) which can be used in 'tie' when an element
        -: 2825:  // of a tuple is not required.
        -: 2826:  // _GLIBCXX14_CONSTEXPR
        -: 2827:  // 2933. PR for LWG 2773 could be clearer
        -: 2828:  struct _Swallow_assign
        -: 2829:  {
        -: 2830:    template<class _Tp>
        -: 2831:      _GLIBCXX14_CONSTEXPR const _Swallow_assign&
        -: 2832:      operator=(const _Tp&) const
        -: 2833:      { return *this; }
        -: 2834:  };
        -: 2835:
        -: 2836:  // _GLIBCXX_RESOLVE_LIB_DEFECTS
        -: 2837:  // 2773. Making std::ignore constexpr
        -: 2838:  /** Used with `std::tie` to ignore an element of a tuple
        -: 2839:   *
        -: 2840:   * When using `std::tie` to assign the elements of a tuple to variables,
        -: 2841:   * unwanted elements can be ignored by using `std::ignore`. For example:
        -: 2842:   *
        -: 2843:   * ```
        -: 2844:   * int x, y;
        -: 2845:   * std::tie(x, std::ignore, y) = std::make_tuple(1, 2, 3);
        -: 2846:   * ```
        -: 2847:   *
        -: 2848:   * This assignment will perform `x=1; std::ignore=2; y=3;` which results
        -: 2849:   * in the second element being ignored.
        -: 2850:   *
        -: 2851:   * @since C++11
        -: 2852:   */
        -: 2853:  _GLIBCXX17_INLINE constexpr _Swallow_assign ignore{};
        -: 2854:
        -: 2855:  /// Partial specialization for tuples
        -: 2856:  template<typename... _Types, typename _Alloc>
        -: 2857:    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
        -: 2858:
        -: 2859:  // See stl_pair.h...
        -: 2860:  /** "piecewise construction" using a tuple of arguments for each member.
        -: 2861:   *
        -: 2862:   * @param __first Arguments for the first member of the pair.
        -: 2863:   * @param __second Arguments for the second member of the pair.
        -: 2864:   *
        -: 2865:   * The elements of each tuple will be used as the constructor arguments
        -: 2866:   * for the data members of the pair.
        -: 2867:  */
        -: 2868:  template<class _T1, class _T2>
        -: 2869:    template<typename... _Args1, typename... _Args2>
        -: 2870:      _GLIBCXX20_CONSTEXPR
        -: 2871:      inline
        -: 2872:      pair<_T1, _T2>::
        -: 2873:      pair(piecewise_construct_t,
        -: 2874:	   tuple<_Args1...> __first, tuple<_Args2...> __second)
        -: 2875:      : pair(__first, __second,
        -: 2876:	     typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
        -: 2877:	     typename _Build_index_tuple<sizeof...(_Args2)>::__type())
        -: 2878:      { }
        -: 2879:
        -: 2880:  template<class _T1, class _T2>
        -: 2881:    template<typename... _Args1, size_t... _Indexes1,
        -: 2882:	     typename... _Args2, size_t... _Indexes2>
        -: 2883:      _GLIBCXX20_CONSTEXPR inline
        -: 2884:      pair<_T1, _T2>::
        -: 2885:      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
        -: 2886:	   _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
        -: 2887:      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
        -: 2888:	second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
        -: 2889:      { }
        -: 2890:
        -: 2891:#if defined(__cpp_lib_apply) || defined(__cpp_lib_make_from_tuple) // C++ >= 17
        -: 2892:  // Unpack a std::tuple into a type trait and use its value.
        -: 2893:  // For cv std::tuple<_Up> the result is _Trait<_Tp, cv _Up...>::value.
        -: 2894:  // For cv std::tuple<_Up>& the result is _Trait<_Tp, cv _Up&...>::value.
        -: 2895:  // Otherwise the result is false (because we don't know if std::get throws).
        -: 2896:  template<template<typename...> class _Trait, typename _Tp, typename _Tuple>
        -: 2897:    inline constexpr bool __unpack_std_tuple = false;
        -: 2898:
        -: 2899:  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
        -: 2900:    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>>
        -: 2901:      = _Trait<_Tp, _Up...>::value;
        -: 2902:
        -: 2903:  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
        -: 2904:    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&>
        -: 2905:      = _Trait<_Tp, _Up&...>::value;
        -: 2906:
        -: 2907:  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
        -: 2908:    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>>
        -: 2909:      = _Trait<_Tp, const _Up...>::value;
        -: 2910:
        -: 2911:  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
        -: 2912:    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
        -: 2913:      = _Trait<_Tp, const _Up&...>::value;
        -: 2914:#endif
        -: 2915:
        -: 2916:#ifdef __cpp_lib_apply // C++ >= 17
        -: 2917:  template <typename _Fn, typename _Tuple, size_t... _Idx>
        -: 2918:    constexpr decltype(auto)
        -: 2919:    __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
        -: 2920:    {
        -: 2921:      return std::__invoke(std::forward<_Fn>(__f),
        -: 2922:			   std::get<_Idx>(std::forward<_Tuple>(__t))...);
        -: 2923:    }
        -: 2924:
        -: 2925:#if __cpp_lib_tuple_like // >= C++23
        -: 2926:  template <typename _Fn, __tuple_like _Tuple>
        -: 2927:#else
        -: 2928:  template <typename _Fn, typename _Tuple>
        -: 2929:#endif
        -: 2930:    constexpr decltype(auto)
        -: 2931:    apply(_Fn&& __f, _Tuple&& __t)
        -: 2932:    noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>)
        -: 2933:    {
        -: 2934:      using _Indices
        -: 2935:	= make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>;
        -: 2936:      return std::__apply_impl(std::forward<_Fn>(__f),
        -: 2937:			       std::forward<_Tuple>(__t),
        -: 2938:			       _Indices{});
        -: 2939:    }
        -: 2940:#endif
        -: 2941:
        -: 2942:#ifdef __cpp_lib_make_from_tuple // C++ >= 17
        -: 2943:  template <typename _Tp, typename _Tuple, size_t... _Idx>
        -: 2944:    constexpr _Tp
        -: 2945:    __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
        -: 2946:    { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }
        -: 2947:
        -: 2948:#if __cpp_lib_tuple_like // >= C++23
        -: 2949:  template <typename _Tp, __tuple_like _Tuple>
        -: 2950:#else
        -: 2951:  template <typename _Tp, typename _Tuple>
        -: 2952:#endif
        -: 2953:    constexpr _Tp
        -: 2954:    make_from_tuple(_Tuple&& __t)
        -: 2955:    noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>)
        -: 2956:    {
        -: 2957:      constexpr size_t __n = tuple_size_v<remove_reference_t<_Tuple>>;
        -: 2958:#if __has_builtin(__reference_constructs_from_temporary)
        -: 2959:      if constexpr (__n == 1)
        -: 2960:	{
        -: 2961:	  using _Elt = decltype(std::get<0>(std::declval<_Tuple>()));
        -: 2962:	  static_assert(!__reference_constructs_from_temporary(_Tp, _Elt));
        -: 2963:	}
        -: 2964:#endif
        -: 2965:      return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t),
        -: 2966:					 make_index_sequence<__n>{});
        -: 2967:    }
        -: 2968:#endif
        -: 2969:
        -: 2970:#if __cpp_lib_tuple_like // >= C++23
        -: 2971:  template<__tuple_like _TTuple, __tuple_like _UTuple,
        -: 2972:	   template<typename> class _TQual, template<typename> class _UQual,
        -: 2973:	   typename = make_index_sequence<tuple_size_v<_TTuple>>>
        -: 2974:  struct __tuple_like_common_reference;
        -: 2975:
        -: 2976:  template<__tuple_like _TTuple, __tuple_like _UTuple,
        -: 2977:	   template<typename> class _TQual, template<typename> class _UQual,
        -: 2978:	   size_t... _Is>
        -: 2979:    requires requires
        -: 2980:      { typename tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>,
        -: 2981:					  _UQual<tuple_element_t<_Is, _UTuple>>>...>; }
        -: 2982:  struct __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual, index_sequence<_Is...>>
        -: 2983:  {
        -: 2984:    using type = tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>,
        -: 2985:					  _UQual<tuple_element_t<_Is, _UTuple>>>...>;
        -: 2986:  };
        -: 2987:
        -: 2988:  template<__tuple_like _TTuple, __tuple_like _UTuple,
        -: 2989:	   template<typename> class _TQual, template<typename> class _UQual>
        -: 2990:    requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>)
        -: 2991:      && is_same_v<_TTuple, decay_t<_TTuple>>
        -: 2992:      && is_same_v<_UTuple, decay_t<_UTuple>>
        -: 2993:      && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
        -: 2994:      && requires { typename __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type; }
        -: 2995:  struct basic_common_reference<_TTuple, _UTuple, _TQual, _UQual>
        -: 2996:  {
        -: 2997:    using type = typename __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type;
        -: 2998:  };
        -: 2999:
        -: 3000:  template<__tuple_like _TTuple, __tuple_like _UTuple,
        -: 3001:	   typename = make_index_sequence<tuple_size_v<_TTuple>>>
        -: 3002:  struct __tuple_like_common_type;
        -: 3003:
        -: 3004:  template<__tuple_like _TTuple, __tuple_like _UTuple, size_t... _Is>
        -: 3005:    requires requires
        -: 3006:      { typename tuple<common_type_t<tuple_element_t<_Is, _TTuple>,
        -: 3007:				   tuple_element_t<_Is, _UTuple>>...>; }
        -: 3008:  struct __tuple_like_common_type<_TTuple, _UTuple, index_sequence<_Is...>>
        -: 3009:  {
        -: 3010:    using type = tuple<common_type_t<tuple_element_t<_Is, _TTuple>,
        -: 3011:				     tuple_element_t<_Is, _UTuple>>...>;
        -: 3012:  };
        -: 3013:
        -: 3014:  template<__tuple_like _TTuple, __tuple_like _UTuple>
        -: 3015:    requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>)
        -: 3016:      && is_same_v<_TTuple, decay_t<_TTuple>>
        -: 3017:      && is_same_v<_UTuple, decay_t<_UTuple>>
        -: 3018:      && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
        -: 3019:      && requires { typename __tuple_like_common_type<_TTuple, _UTuple>::type; }
        -: 3020:  struct common_type<_TTuple, _UTuple>
        -: 3021:  {
        -: 3022:    using type = typename __tuple_like_common_type<_TTuple, _UTuple>::type;
        -: 3023:  };
        -: 3024:#endif // C++23
        -: 3025:
        -: 3026:  /// @}
        -: 3027:
        -: 3028:#undef __glibcxx_no_dangling_refs
        -: 3029:
        -: 3030:_GLIBCXX_END_NAMESPACE_VERSION
        -: 3031:} // namespace std
        -: 3032:
        -: 3033:#endif // C++11
        -: 3034:
        -: 3035:#endif // _GLIBCXX_TUPLE
